A Windows C + + threading class implementation (encapsulating the API to form a class, but not perfect.) In fact, you can learn the TThread of Delphi)

Thread.h

[CPP]View PlainCopy

2. #ifndef __thread_h__
4. #define __thread_h__
8. #include <string>
12. #include <windows.h>
14. #include <process.h>
18. Class Runnable
20. {
22. Public
24. Virtual ~runnable () {};
26. virtual void Run () = 0;
28. };
32. Class Cthread: Public Runnable
34. {
36. Private
38. explicit Cthread (const cthread & RHS);
42. Public
44. Cthread ();
46. Cthread (Runnable * prunnable);
48. Cthread (const char * threadname, Runnable * prunnable = NULL);
50. Cthread (std::string threadname, Runnable * prunnable = NULL);
52. ~cthread (void);
56. /** 
58. Start Running Threads
60. @arg whether Bsuspend hangs when it starts running
62. **/
64. bool Start (bool bsuspend = false);
68. /** 
70. Run a thread function that can be overridden with a derived class
72. **/
74. virtual void Run ();
78. /** 
80. Currently executing this function thread waits for thread to end
82. @arg Timeout Wait timeout, if negative, wait for unlimited duration
84. **/
86. void Join (int timeout =-1);
88. /** 
90. Recovering a suspended thread
92. **/
94. void Resume ();
96. /** 
98. Suspending threads
100. **/
102. void Suspend ();
104. /** 
106. Terminating the execution of a thread
108. **/
110. bool Terminate (unsigned long ExitCode);
114. unsigned int getthreadid ();
116. std::string getthreadname ();
118. void SetThreadName (std::string threadname);
120. void SetThreadName (const char * threadname);
124. Private
126. static unsigned int WINAPI staticthreadfunc (void * arg);
130. Private
132. HANDLE M_handle;
134. Runnable * const m_prunnable;
136. unsigned int m_threadid;
138. Std::string M_threadname;
140. volatile bool M_brun;
142. };
146. #endif

Thread.cpp

[CPP]View PlainCopy

2. #include "Thread.h"
6. Cthread::cthread (void):
8. M_prunnable (NULL),
10. M_brun (false)
12. {
14. }
18. Cthread::~cthread (void)
20. {
22. }
26. Cthread::cthread (Runnable * prunnable):
28. M_threadname (""),
30. M_prunnable (prunnable),
32. M_brun (false)
34. {
36. }
40. Cthread::cthread (const char * threadname, Runnable * prunnable):
42. M_threadname (ThreadName),
44. M_prunnable (prunnable),
46. M_brun (false)
48. {
50. }
54. Cthread::cthread (std::string threadname, Runnable * prunnable):
56. M_threadname (ThreadName),
58. M_prunnable (prunnable),
60. M_brun (false)
62. {
64. }
68. BOOL Cthread::start (bool bsuspend)
70. {
72. if (m_brun)
74. {
76. return true;
78. }
80. if (bsuspend)
82. {
84. M_handle = (handle) _beginthreadex (NULL, 0, Staticthreadfunc, this , create_suspended, &m_threadid);
86. }
88. Else
90. {
92. M_handle = (handle) _beginthreadex (NULL, 0, Staticthreadfunc, this , 0, &m_threadid);
94. }
96. M_brun = (NULL! = M_handle);
98. return m_brun;
100. }
104. void Cthread::run ()
106. {
108. if (!m_brun)
110. {
112. return;
114. }
116. if (NULL! = m_prunnable)
118. {
120. M_prunnable->run ();
122. }
124. M_brun = false;
126. }
130. void Cthread::join (int timeout)
132. {
134. if (NULL = = M_handle | |!m_brun)
136. {
138. return;
140. }
142. if (timeout <= 0)
144. {
146. Timeout = INFINITE;
148. }
150. :: WaitForSingleObject (M_handle, timeout);
152. }
156. void Cthread::resume ()
158. {
160. if (NULL = = M_handle | |!m_brun)
162. {
164. return;
166. }
168. :: ResumeThread (M_handle);
170. }
174. void Cthread::suspend ()
176. {
178. if (NULL = = M_handle | |!m_brun)
180. {
182. return;
184. }
186. :: SuspendThread (M_handle);
188. }
192. BOOL Cthread::terminate (unsigned long ExitCode)
194. {
196. if (NULL = = M_handle | |!m_brun)
198. {
200. return true;
202. }
204. if (:: TerminateThread (M_handle, ExitCode))
206. {
208. :: CloseHandle (M_handle);
210. return true;
212. }
214. return false;
216. }
220. unsigned int cthread::getthreadid ()
222. {
224. return m_threadid;
226. }
230. std::string Cthread::getthreadname ()
232. {
234. return m_threadname;
236. }
240. void Cthread::setthreadname (std::string threadname)
242. {
244. M_threadname = ThreadName;
246. }
250. void Cthread::setthreadname (const char * threadname)
252. {
254. if (NULL = = threadname)
256. {
258. M_threadname = "";
260. }
262. Else
264. {
266. M_threadname = ThreadName;
268. }
270. }
274. unsigned int cthread::staticthreadfunc (void * arg)
276. {
278. Cthread * PThread = (Cthread *) arg;
280. Pthread->run ();
282. return 0;
284. }

Usage:

#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

A Windows C + + threading class implementation (encapsulating the API to form a class, but not perfect.) In fact, you can learn the TThread of Delphi)