MFC多线程编程：从基础到实战技巧

1. MFC线程管理基础概念

在Windows平台使用MFC框架开发时，线程管理是每个开发者必须掌握的核心技能。不同于简单的单线程程序，多线程编程能让我们的应用同时处理多个任务，比如在后台执行耗时计算的同时保持UI响应流畅。但这也带来了新的挑战——如何安全地创建、控制这些并行执行的线程？

MFC对Win32线程API进行了面向对象封装，主要提供了CWinThread类作为线程操作的基类。实际开发中，我们通常会从CWinThread派生自己的线程类，或者直接使用AfxBeginThread函数快速创建工作者线程。无论哪种方式，都需要理解线程的四种基本状态：启动（Create）、挂起（Suspend）、恢复（Resume）和停止（Terminate）。

重要提示：直接调用TerminateThread强制结束线程是危险操作，可能导致资源泄漏。正确的做法是通过事件(Event)或标志变量让线程安全退出。

2. 线程启动的三种典型方式

2.1 使用AfxBeginThread创建工作者线程

这是MFC中最快捷的线程创建方式，适合不需要复杂控制的场景。下面是一个典型的工作者线程创建示例：

cpp复制// 线程执行函数
UINT WorkerThreadProc(LPVOID pParam)
{
    CString* pStr = (CString*)pParam;
    TRACE(_T("Worker thread started with param: %s\n"), *pStr);
    
    // 模拟耗时操作
    for(int i=0; i<10; i++) {
        Sleep(1000);
        TRACE(_T("Working... %d\n"), i);
    }
    
    return 0; // 线程正常退出
}

// 在UI线程中启动工作者线程
void CMyDialog::OnStartWorkerThread()
{
    CString* pParam = new CString(_T("Hello Thread"));
    CWinThread* pThread = AfxBeginThread(
        WorkerThreadProc,  // 线程函数
        pParam,            // 参数
        THREAD_PRIORITY_NORMAL, // 优先级
        0,                 // 堆栈大小(0表示默认)
        CREATE_SUSPENDED   // 创建标志
    );
    
    if(pThread) {
        m_pWorkerThread = pThread; // 保存线程指针
        pThread->ResumeThread();   // 如果创建时挂起，需要恢复
    }
}

关键参数说明：

• 第4个参数为0表示使用默认堆栈大小（通常1MB）
• CREATE_SUSPENDED标志让线程创建后处于挂起状态，便于后续控制
• 线程函数返回值为退出代码，可通过GetExitCodeThread获取

2.2 派生CWinThread实现UI线程

当需要创建带消息循环的线程时（如辅助UI线程），应该从CWinThread派生类：

cpp复制class CMyUIThread : public CWinThread
{
    DECLARE_DYNCREATE(CMyUIThread)
public:
    virtual BOOL InitInstance() {
        m_pMainWnd = new CMyFrameWnd();
        m_pMainWnd->ShowWindow(SW_SHOW);
        return TRUE;
    }
    
    virtual int ExitInstance() {
        if(m_pMainWnd) {
            m_pMainWnd->DestroyWindow();
            delete m_pMainWnd;
        }
        return CWinThread::ExitInstance();
    }
};

// 启动UI线程
void CMyApp::StartUIThread()
{
    CMyUIThread* pThread = (CMyUIThread*)AfxBeginThread(
        RUNTIME_CLASS(CMyUIThread),
        THREAD_PRIORITY_NORMAL,
        0,
        CREATE_SUSPENDED
    );
    
    if(pThread) {
        pThread->ResumeThread();
    }
}

2.3 使用_beginthreadex的注意事项

虽然MFC提供了自己的线程创建函数，但有时我们可能需要使用C运行时库的_beginthreadex。这种情况下需要特别注意：

cpp复制#include <process.h>

unsigned __stdcall ThreadFunc(void* pArg)
{
    // 必须调用此函数初始化MFC线程状态
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    
    // 线程代码...
    return 0;
}

void StartCRTThread()
{
    unsigned threadID;
    HANDLE hThread = (HANDLE)_beginthreadex(
        NULL, 0, ThreadFunc, NULL, 0, &threadID);
    
    if(hThread) {
        CloseHandle(hThread); // 注意关闭句柄避免泄漏
    }
}

常见陷阱：使用_beginthreadex创建的线程如果不调用AFX_MANAGE_STATE，可能导致MFC资源查找失败或断言错误。

3. 线程挂起与恢复的深入实践

3.1 挂起计数机制解析

MFC中的SuspendThread/ResumeThread实际上是调用Win32 API，它们使用计数器机制：

cpp复制// 假设线程当前运行中
DWORD nSuspendCount = pThread->SuspendThread(); // 返回0，现在计数=1
nSuspendCount = pThread->SuspendThread();       // 返回1，现在计数=2

nSuspendCount = pThread->ResumeThread();        // 返回2，现在计数=1
nSuspendCount = pThread->ResumeThread();        // 返回1，现在计数=0(线程恢复运行)
nSuspendCount = pThread->ResumeThread();        // 返回0，计数保持0

关键点：

• 每次SuspendThread增加计数，返回前一个计数值
• 只有计数为0时线程才真正运行
• 过度挂起可能导致死锁，特别是在持有锁的情况下

3.2 安全挂起的最佳实践

cpp复制// 错误示例：可能导致死锁
void UnsafeSuspend()
{
    EnterCriticalSection(&m_cs); // 获取锁
    // 如果在此处被挂起...
    pThread->SuspendThread();    // 危险！
    LeaveCriticalSection(&m_cs);
}

// 正确做法：使用事件通知
void SafeSuspendRequest()
{
    m_bSuspendRequested = TRUE;  // 原子变量更佳
    // 线程函数中应定期检查此标志
}

// 工作者线程中的检查点
UINT WorkerThreadProc(LPVOID)
{
    while(!m_bAbort) {
        if(m_bSuspendRequested) {
            m_bSuspended = TRUE;
            while(m_bSuspendRequested && !m_bAbort) {
                Sleep(100); // 短暂休眠
            }
            m_bSuspended = FALSE;
        }
        // 正常处理...
    }
    return 0;
}

3.3 挂起状态检测技巧

由于没有直接获取挂起计数的API，我们可以通过以下方式间接判断：

cpp复制bool IsThreadSuspended(HANDLE hThread)
{
    DWORD dwSuspendCount = ::SuspendThread(hThread);
    if(dwSuspendCount != (DWORD)-1) {
        ::ResumeThread(hThread); // 恢复原状态
        return dwSuspendCount > 0;
    }
    return false; // 线程可能已终止
}

4. 线程停止的安全方案

4.1 优雅停止的标准模式

强制终止线程会导致资源泄漏，推荐使用事件或标志变量：

cpp复制// 在工作者线程类中
class CMyWorkerThread : public CWinThread
{
public:
    CEvent m_evtStop; // 停止事件
    
    UINT Run()
    {
        while(::WaitForSingleObject(m_evtStop, 0) != WAIT_OBJECT_0) {
            // 正常工作...
            ProcessTask();
        }
        return 0;
    }
};

// 在主线程中请求停止
void StopWorkerThread()
{
    if(m_pWorkerThread) {
        m_pWorkerThread->m_evtStop.SetEvent();
        ::WaitForSingleObject(m_pWorkerThread->m_hThread, INFINITE);
    }
}

4.2 超时停止的健壮实现

对于可能卡住的线程，应实现带超时的停止：

cpp复制bool StopThreadWithTimeout(CWinThread* pThread, DWORD dwTimeout)
{
    if(!pThread) return true;
    
    pThread->m_evtStop.SetEvent();
    
    DWORD dwStart = GetTickCount();
    while(GetTickCount() - dwStart < dwTimeout) {
        if(WaitForSingleObject(pThread->m_hThread, 50) == WAIT_OBJECT_0) {
            return true; // 线程已退出
        }
    }
    
    // 超时后强制终止（最后手段）
    TerminateThread(pThread->m_hThread, (DWORD)-1);
    return false;
}

4.3 线程清理的完整流程

确保线程退出时释放所有资源：

cpp复制UINT WorkerThreadProc(LPVOID pParam)
{
    // 资源初始化
    CMyResource* pRes = new CMyResource;
    
    try {
        while(!m_bAbort) {
            // 工作循环...
        }
    }
    catch(...) {
        // 异常处理
    }
    
    // 清理资源
    delete pRes;
    
    // 通知主线程（可选）
    ::PostMessage(m_hNotifyWnd, WM_THREAD_EXITED, 0, 0);
    
    return 0;
}

5. 实战中的常见问题与解决方案

5.1 跨线程UI访问的正确方式

MFC中直接跨线程访问UI控件是危险的，应该使用消息传递：

cpp复制// 工作者线程发送进度更新
void PostProgress(int nPercent)
{
    if(::IsWindow(m_hNotifyWnd)) {
        ::PostMessage(m_hNotifyWnd, WM_PROGRESS_UPDATE, nPercent, 0);
    }
}

// 在主窗口类中处理消息
BEGIN_MESSAGE_MAP(CMyDialog, CDialog)
    ON_MESSAGE(WM_PROGRESS_UPDATE, OnProgressUpdate)
END_MESSAGE_MAP()

LRESULT CMyDialog::OnProgressUpdate(WPARAM wp, LPARAM)
{
    m_progressCtrl.SetPos((int)wp); // 安全更新UI
    return 0;
}

5.2 线程优先级管理经验

调整线程优先级可以影响调度，但需谨慎：

cpp复制// 设置线程优先级（范围：THREAD_PRIORITY_IDLE到THREAD_PRIORITY_TIME_CRITICAL）
pThread->SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);

// 获取当前优先级
int nPriority = pThread->GetThreadPriority();

实际经验：长时间运行的后台线程应设为BELOW_NORMAL，避免抢占UI线程资源。但实时性要求高的线程（如视频播放）可能需要ABOVE_NORMAL。

5.3 线程局部存储(TLS)的应用

使用TLS保存线程特定数据：

cpp复制// 分配TLS索引（通常在应用初始化时）
DWORD dwTlsIndex = ::TlsAlloc();

// 在线程中存储数据
void SetThreadData(void* pData)
{
    ::TlsSetValue(dwTlsIndex, pData);
}

// 获取线程数据
void* GetThreadData()
{
    return ::TlsGetValue(dwTlsIndex);
}

// 释放TLS索引（应用退出时）
::TlsFree(dwTlsIndex);

5.4 死锁预防策略

多线程编程中最棘手的问题之一，预防措施包括：

1. 锁顺序一致性：所有线程按相同顺序获取锁
2. 锁超时机制：使用TryEnterCriticalSection或带超时的等待
3. 避免嵌套锁：尽量减少锁的嵌套层次
4. 使用RAII管理锁：

cpp复制class CScopedLock
{
public:
    CScopedLock(CCriticalSection& cs) : m_cs(cs) { m_cs.Lock(); }
    ~CScopedLock() { m_cs.Unlock(); }
private:
    CCriticalSection& m_cs;
};

// 使用示例
void SafeOperation()
{
    CScopedLock lock(m_cs); // 自动加锁
    // 操作共享资源...
} // 自动解锁

6. 性能优化与调试技巧

6.1 线程池替代方案

频繁创建销毁线程代价高，可考虑线程池：

cpp复制// 使用Windows线程池
void SubmitThreadpoolWork()
{
    PTP_WORK pWork = CreateThreadpoolWork(
        [](PTP_CALLBACK_INSTANCE, PVOID pContext, PTP_WORK) {
            // 工作代码...
        }, nullptr, nullptr);
    
    if(pWork) {
        SubmitThreadpoolWork(pWork);
        // 不再需要时调用CloseThreadpoolWork
    }
}

// MFC自带CThreadPool（需要AFX_EXTDLL）
class CMyTask : public CBaseTask
{
public:
    virtual DWORD Process()
    {
        // 任务处理...
        return 0;
    }
};

void UseMFCThreadPool()
{
    CThreadPool pool;
    pool.Initialize(3); // 3个工作线程
    
    CMyTask* pTask = new CMyTask;
    pool.AddTask(pTask);
    
    pool.Shutdown(); // 等待所有任务完成
}

6.2 线程同步性能对比

不同同步机制的性能特点：

6.3 调试多线程程序的技巧

1. 使用TRACE宏输出线程日志：

cpp复制TRACE(_T("[ThreadID=%d] Operation started\n"), ::GetCurrentThreadId());

2. 在Visual Studio中：

• 调试时打开"线程"窗口（Debug > Windows > Threads）
• 设置线程名称便于识别：

cpp复制#pragma pack(push,8)
typedef struct tagTHREADNAME_INFO {
    DWORD dwType;     // 必须为0x1000
    LPCSTR szName;    // 线程名称
    DWORD dwThreadID; // 线程ID(-1表示当前线程)
    DWORD dwFlags;    // 保留，必须为0
} THREADNAME_INFO;
#pragma pack(pop)

void SetThreadName(DWORD dwThreadID, LPCSTR szThreadName)
{
    THREADNAME_INFO info = {0x1000, szThreadName, dwThreadID, 0};
    __try {
        RaiseException(0x406D1388, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info);
    } __except(EXCEPTION_CONTINUE_EXECUTION) {
    }
}

3. 使用性能分析工具：

• Visual Studio性能探查器
• Process Explorer查看线程CPU占用
• Windows Performance Recorder(WPR)记录详细线程活动

7. 现代C++中的线程替代方案

虽然本文聚焦MFC线程管理，但在支持C++11及更高版本的项目中，可以考虑：

7.1 std::thread基础用法

cpp复制#include <thread>

void ThreadFunction(int param)
{
    // 线程代码...
}

void StartStdThread()
{
    std::thread t(ThreadFunction, 42);
    t.detach(); // 或 t.join()等待结束
}

7.2 与MFC线程的互操作

cpp复制// 将std::thread转换为CWinThread*
CWinThread* MakeMFCThread(std::thread&& t)
{
    HANDLE hThread = t.native_handle();
    t.detach();
    
    CWinThread* pThread = new CWinThread;
    pThread->m_hThread = hThread;
    pThread->m_nThreadID = ::GetThreadId(hThread);
    return pThread;
}

注意：混合使用不同线程模型时需要谨慎处理资源所有权和生命周期。