C++封装线程类的实现方法

/*
外面调用这个类时，只需要IsRunning() Startxxx(xxx) Suspendxxx() Resumexxx() Stopxxx()
*/

/*
m_bContinue在真正的工作代码DoSomething中检测，在退出和类析构时设为FALSE,在Reset时和构造时设为TRUE 标志内部是否继续工作
m_bRunning 在Startxxx Suspendxxx Resumexxx 中检测，在构造时和Reset时设为FALSE,在_ThreadEntry得到WaitForSingleObject时设为TRUE
外部通过IsRunning得到是否正在运行

*/
class CMyClass
{
public:
// 工作退出代码
enum ExitCode{
exitSuccess, // 成功完成任务
exitUserForce, // 用户终止
exitError, // 源文件出错
};

// 构造函数
CMyClass(HWND hWndNotify); //接收窗口句柄

// 属性 对外开放
BOOL IsRunning() const { return m_bRunning; } //对外

// 操作 对外开放
BOOL Startxxx(xxx);
BOOL Suspendxxx();
BOOL Resumexxx();
void Stopxxx();

// 具体实现
public:
~CFileCutter(); //析构

protected:
// 重置参数信息和状态标志
void Reset();
// 真正的工作核心代码
void DoSomething();

// 工作线程
UINT friend _ThreadEntry(LPVOID lpParam);

// 状态标志
BOOL m_bContinue; // 是否继续工作 DoSomething中检测，如果在DoSomething中不m_bContinue，就中止工作
BOOL m_bRunning; // 是否处于工作状态

// 同步以上两组数据
CRITICAL_SECTION m_cs; // Data gard

private:
// 对象的生命周期全局有效的数据
HWND m_hWndNotify; // 接受消息通知事件的窗口句柄
HANDLE m_hWorkEvent; // 通知开始工作的事件对象句柄
CWinThread* m_pThread; // 工作线程
BOOL m_bSuspend; // 暂停标志
BOOL m_bExitThread; // 退出标志
};

//构造
CMyClass::CMyClass()
{
// 初始化全局有效变量

m_hWndNotify = hWndNotify;
m_bExitThread = FALSE;
m_bSuspend = FALSE;
// 创建等待事件对象
m_hWorkEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
// 创建工作线程
m_pThread = AfxBeginThread(_CutterEntry, this, THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED, NULL);
m_pThread->m_bAutoDelete = FALSE;
m_pThread->ResumeThread();

// 初始化工作期间有效变量
m_bContinue = TRUE; //工作函数不被打断，这个标志就为TRUE,在工作函数中检测这个值
m_bRunning = FALSE; //线程函数在WaitForSingleObject，所以还是FALSE
// 创建关键代码段
::InitializeCriticalSection(&m_cs);
}

// 内部工作线程
UINT _ThreadEntry(LPVOID lpParam)
{
// 得到CMyClass对象的指针
CMyClass* pMyClass = (CMyClass*)lpParam;

// 循环处理用户的工作请求
while(::WaitForSingleObject(pMyClass->m_hWorkEvent, INFINITE) == WAIT_OBJECT_0 &&
!pMyClass->m_bExitThread)
{
// 设置状态标志，说明正在工作
::EnterCriticalSection(&pCutter->m_cs);
pMyClass->m_bRunning = TRUE;
::LeaveCriticalSection(&pCutter->m_cs);

// 开始真正的工作
pMyClass->DoSomething()

// 准备接受新的工作任务
pMyClass->Reset(); //这个函数中设置一下各标志的值
}

return 0;
}

void CMyClass::Reset()
{
::EnterCriticalSection(&m_cs);

// 重置状态标志
m_bContinue = TRUE;
m_bRunning = FALSE;

::LeaveCriticalSection(&m_cs);
}

CMyClass::~CMyClass()
{
// 设置结束标志
m_bExitThread = TRUE;

// 设置强制退出标志
::EnterCriticalSection(&m_cs);
m_bContinue = FALSE;
::LeaveCriticalSection(&m_cs);

//**********很重要******************************************
// 防止线程在m_hWorkEvent事件上等待
::SetEvent(m_hWorkEvent);

// 确保工作线程结束
::WaitForSingleObject(m_pThread->m_hThread, INFINITE);

// 释放所有资源
::CloseHandle(m_hWorkEvent);
::DeleteCriticalSection(&m_cs);
delete m_pThread;
}

BOOL CMyClass::Startxxx(xxx)
{
if(m_bRunning)
return FALSE;

// 通知线程开始工作
::SetEvent(m_hWorkEvent);
return TRUE;
}

BOOL CMyClass::Suspendxxx()
{
if(!m_bRunning)
return FALSE;

// 暂停工作线程
if(!m_bSuspend)
{
m_pThread->SuspendThread();
m_bSuspend = TRUE;
}
return TRUE;
}

BOOL CMyClass::Resumexxx()
{
if(!m_bRunning)
return FALSE;

// 唤醒工作线程
if(m_bSuspend)
{
m_pThread->ResumeThread();
m_bSuspend = FALSE;
}
return TRUE;
}

void CMyClass::Stopxxx()
{
// 设置强制退出标志
::EnterCriticalSection(&m_cs);
m_bContinue = FALSE;
::LeaveCriticalSection(&m_cs);

// 防止线程处于暂停状态
ResumeCutter();
}

//————————-实现代码————————-//

//真正的工作代码
void CMyClass::DoSomething()
{
// 通知用户，出错
::PostMessage(m_hWndNotify, wm_xxx, exitError, 0);

// 通知用户，开始工作
::PostMessage(m_hWndNotify, WM_XXXSTART, 0, XX);

// 首先判断是否要求终止执行
if(!m_bContinue)
{
//释放资源
xxxx;

if(!m_bExitThread)
::PostMessage(m_hWndNotify, WM_XXXXSTOP, XX, XX);
return;
}
// 通知用户，工作完成
::PostMessage(m_hWndNotify, WM_CUTTERSTOP, exitSuccess, nCompleted);
}

希望本文所述对大家的C++程序设计有所帮助。