一个Windows C++的线程类实现（封装API，形成一个类，但不完善。其实可以学习一下Delphi的TThread的写法）

Thread.h

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

Thread.cpp

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

用法：

#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();

}

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