关闭

一个windows线程类的实现

标签: windows线程池
235人阅读 评论(0) 收藏 举报
分类:

Thread.h

 

  1. #ifndef __THREAD_H__  
  2. #define __THREAD_H__  
  3.   
  4. #include <string>  
  5.   
  6. #include   <windows.h>  
  7. #include   <process.h>  
  8.   
  9. class Runnable  
  10. {  
  11. public:  
  12.     virtual ~Runnable() {};  
  13.     virtual void Run() = 0;  
  14. };  
  15.   
  16. class CThread : public Runnable  
  17. {  
  18. private:  
  19.     explicit CThread(const CThread & rhs);  
  20.   
  21. public:  
  22.     CThread();  
  23.     CThread(Runnable * pRunnable);  
  24.     CThread(const char * ThreadName, Runnable * pRunnable = NULL);  
  25.     CThread(std::string ThreadName, Runnable * pRunnable = NULL);  
  26.     ~CThread(void);  
  27.   
  28.     /** 
  29.       开始运行线程 
  30.       @arg bSuspend 开始运行时是否挂起 
  31.     **/  
  32.     bool Start(bool bSuspend = false);  
  33.   
  34.     /** 
  35.       运行的线程函数,可以使用派生类重写此函数 
  36.     **/  
  37.     virtual void Run();  
  38.   
  39.     /** 
  40.       当前执行此函数线程等待线程结束 
  41.       @arg timeout 等待超时时间,如果为负数,等待无限时长 
  42.     **/  
  43.     void Join(int timeout = -1);  
  44.     /** 
  45.       恢复挂起的线程 
  46.     **/  
  47.     void Resume();  
  48.     /** 
  49.       挂起线程 
  50.     **/  
  51.     void Suspend();  
  52.     /** 
  53.       终止线程的执行 
  54.     **/  
  55.     bool Terminate(unsigned long ExitCode);  
  56.   
  57.     unsigned int GetThreadID();  
  58.     std::string GetThreadName();  
  59.     void SetThreadName(std::string ThreadName);  
  60.     void SetThreadName(const char * ThreadName);  
  61.   
  62. private:  
  63.     static unsigned int WINAPI StaticThreadFunc(void * arg);  
  64.   
  65. private:  
  66.     HANDLE m_handle;  
  67.     Runnable * const m_pRunnable;  
  68.     unsigned int m_ThreadID;  
  69.     std::string m_ThreadName;  
  70.     volatile bool m_bRun;  
  71. };  
  72.   
  73. #endif  

 

 

Thread.cpp

 

  1. #include "Thread.h"  
  2.   
  3. CThread::CThread(void) :   
  4. m_pRunnable(NULL),  
  5. m_bRun(false)  
  6. {  
  7. }  
  8.   
  9. CThread::~CThread(void)  
  10. {  
  11. }  
  12.   
  13. CThread::CThread(Runnable * pRunnable) :   
  14. m_ThreadName(""),  
  15. m_pRunnable(pRunnable),  
  16. m_bRun(false)  
  17. {  
  18. }  
  19.   
  20. CThread::CThread(const char * ThreadName, Runnable * pRunnable) :   
  21. m_ThreadName(ThreadName),  
  22. m_pRunnable(pRunnable),  
  23. m_bRun(false)  
  24. {  
  25. }  
  26.   
  27. CThread::CThread(std::string ThreadName, Runnable * pRunnable) :   
  28. m_ThreadName(ThreadName),  
  29. m_pRunnable(pRunnable),  
  30. m_bRun(false)  
  31. {  
  32. }  
  33.   
  34. bool CThread::Start(bool bSuspend)  
  35. {  
  36.     if(m_bRun)  
  37.     {  
  38.         return true;  
  39.     }  
  40.     if(bSuspend)  
  41.     {  
  42.         m_handle = (HANDLE)_beginthreadex(NULL, 0, StaticThreadFunc, this, CREATE_SUSPENDED, &m_ThreadID);  
  43.     }  
  44.     else  
  45.     {  
  46.         m_handle = (HANDLE)_beginthreadex(NULL, 0, StaticThreadFunc, this, 0, &m_ThreadID);  
  47.     }  
  48.     m_bRun = (NULL != m_handle);  
  49.     return m_bRun;  
  50. }  
  51.   
  52. void CThread::Run()  
  53. {  
  54.     if(!m_bRun)  
  55.     {  
  56.         return;  
  57.     }  
  58.     if(NULL != m_pRunnable)  
  59.     {  
  60.         m_pRunnable->Run();  
  61.     }  
  62.     m_bRun = false;  
  63. }  
  64.   
  65. void CThread::Join(int timeout)  
  66. {  
  67.     if(NULL == m_handle || !m_bRun)  
  68.     {  
  69.         return;  
  70.     }  
  71.     if(timeout <= 0)  
  72.     {  
  73.         timeout = INFINITE;  
  74.     }  
  75.     ::WaitForSingleObject(m_handle, timeout);  
  76. }  
  77.   
  78. void CThread::Resume()  
  79. {  
  80.     if(NULL == m_handle || !m_bRun)  
  81.     {  
  82.         return;  
  83.     }  
  84.     ::ResumeThread(m_handle);  
  85. }  
  86.   
  87. void CThread::Suspend()  
  88. {  
  89.     if(NULL == m_handle || !m_bRun)  
  90.     {  
  91.         return;  
  92.     }  
  93.     ::SuspendThread(m_handle);  
  94. }  
  95.   
  96. bool CThread::Terminate(unsigned long ExitCode)  
  97. {  
  98.     if(NULL == m_handle || !m_bRun)  
  99.     {  
  100.         return true;  
  101.     }  
  102.     if(::TerminateThread(m_handle, ExitCode))  
  103.     {  
  104.         ::CloseHandle(m_handle);  
  105.         return true;  
  106.     }  
  107.     return false;  
  108. }  
  109.   
  110. unsigned int CThread::GetThreadID()  
  111. {  
  112.     return m_ThreadID;  
  113. }  
  114.   
  115. std::string CThread::GetThreadName()  
  116. {  
  117.     return m_ThreadName;  
  118. }  
  119.   
  120. void CThread::SetThreadName(std::string ThreadName)  
  121. {  
  122.     m_ThreadName = ThreadName;  
  123. }  
  124.   
  125. void CThread::SetThreadName(const char * ThreadName)  
  126. {  
  127.     if(NULL == ThreadName)  
  128.     {  
  129.         m_ThreadName = "";  
  130.     }  
  131.     else  
  132.     {  
  133.         m_ThreadName = ThreadName;  
  134.     }  
  135. }  
  136.   
  137. unsigned int CThread::StaticThreadFunc(void * arg)  
  138. {  
  139.     CThread * pThread = (CThread *)arg;  
  140.     pThread->Run();  
  141.     return 0;  
  142. }  

 

 

用法:

#include "Thread.h"
#include "ThreadPoolExecutor.h"

class R : public Runnable
{
public:
    ~R()
    {
        printf("~R/n");
    }
    void Run()
    {
        printf("Hello World/n");
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    R r;
    CThread * t = NULL;
    t = new CThread(&r);
    t->Start();
    t->Join();

    getchar();

}

 

from:http://blog.csdn.net/huyiyang2010/article/details/5801597

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:292907次
    • 积分:4312
    • 等级:
    • 排名:第7021名
    • 原创:56篇
    • 转载:547篇
    • 译文:0篇
    • 评论:18条
    最新评论