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

本文实例讲述了C++封装线程类的实现方法。分享给大家供大家参考。具体方法如下：

// 给主窗口的通知消息

#define WM_CUTTERSTART WM_USER + 100    // wParam == xxx  lParam==xxxx

/*

外面调用这个类时，只需要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++程序设计有所帮助。