一个Windows C++的线程类实现

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