Windows线程管理与封装

 

在进行编程时，难免会进行多线程的操作，win32 api使用起来诸多不便，因此我用C++封装了一下。
包含：
线程基类Thread
线程组管理ThreadManager
临界区锁CriticalSection

当然实际运用中不可能只有这点，大家根据需要自己加代码完成吧。比如事件锁，互斥锁，信号锁等等

 

001 #include <windows.h>
002 #include <iostream>
003 #include <string>
004 #include <vector>
005 #include <process.h>
006 #include <assert.h>
007
008 // Thread.h --------------------------------------
009
010 /* 线程封装 */
011 class Thread
012 {
013 public:
014     typedef unsigned long handle_t;
015     typedef unsigned ( __stdcall * start_routine )( void * param );
016     bool want_stop;
017     bool auto_delete;
018     unsigned thread_id;
019     unsigned exit_code;
020
021     Thread( void );
022     virtual ~Thread( void );
023     virtual void run() = 0;
024
025     void start( void );
026     void pause( void );
027     void close( void );
028     void wait( unsigned long ms = INFINITE );
029     void forceStop( void );
030
031     handle_t handle( void ) { return _thread; }
032 private:
033     handle_t _thread;
034     static unsigned __stdcall _start_run( Thread * thread_ptr );
035
036     Thread( Thread const & );
037     Thread & operator = ( Thread const & );
038 };
039
040 // Thread.cpp ------------------------------------
041 Thread::Thread( void ) : _thread(0), thread_id(0), want_stop(false), auto_delete(true), exit_code(0)
042 {
043     _thread = _beginthreadex( NULL, 0, (start_routine)_start_run, this, CREATE_SUSPENDED, &this->thread_id );
044 }
045
046 Thread::~Thread( void )
047 {
048     this->close();
049 }
050
051 void Thread::start( void )
052 {
053     ResumeThread( (HANDLE)_thread );
054 }
055
056 void Thread::pause( void )
057 {
058     SuspendThread( (HANDLE)_thread );
059 }
060
061 void Thread::close( void )
062 {
063     if ( _thread )
064     {
065         CloseHandle( (HANDLE)_thread );
066         _thread = 0;
067     }
068 }
069
070 void Thread::wait( unsigned long ms /*= INFINITE */ )
071 {
072     WaitForSingleObject( (HANDLE)_thread, ms );
073 }
074
075 unsigned __stdcall Thread::_start_run( Thread * thread_ptr )
076 {
077     thread_ptr->run();
078     unsigned exit_code = thread_ptr->exit_code;
079
080     if ( thread_ptr->auto_delete )
081         delete thread_ptr;
082
083     return exit_code;
084 }
085
086 void Thread::forceStop( void )
087 {
088     TerminateThread( (HANDLE)_thread, exit_code );
089 }
090
091 // ThreadManager.h ----------------------------------------
092 /* 线程管理器 */
093 template <typename _Thread> class ThreadManager
094 {
095 public:
096     typedef typename std::vector<_Thread *> thread_array;
097
098     ThreadManager( void ) {}
099     ~ThreadManager( void )
100     {
101         thread_array::iterator it;
102         for ( it = _thread_arr.begin(); it != _thread_arr.end(); it++ )
103         {
104             delete *it;
105         }
106         _thread_arr.clear();
107     }
108     template <typename _ARG_T1> void create( int count, _ARG_T1 arg1 )
109     {
110         int i;
111         for ( i = 0; i < count; i++ )
112         {
113             _Thread * th_ptr = new _Thread(arg1);
114             th_ptr->auto_delete = false;
115             _thread_arr.push_back(th_ptr);
116         }
117     }
118     template < typename _ARG_T1, typename _ARG_T2 > void create( int count, _ARG_T1 arg1, _ARG_T2 arg2 )
119     {
120         int i;
121         for ( i = 0; i < count; i++ )
122         {
123             _Thread * th_ptr = new _Thread( arg1, arg2 );
124             th_ptr->auto_delete = false;
125             _thread_arr.push_back(th_ptr);
126         }
127     }
128     template < typename _ARG_T1, typename _ARG_T2, typename _ARG_T3> void create( int count, _ARG_T1 arg1, _ARG_T2 arg2, _ARG_T3 arg3 )
129     {
130         int i;
131         for ( i = 0; i < count; i++ )
132         {
133             _Thread * th_ptr = new _Thread( arg1, arg2, arg3 );
134             th_ptr->auto_delete = false;
135             _thread_arr.push_back(th_ptr);
136         }
137     }
138     void create( int count )
139     {
140         int i;
141         for ( i = 0; i < count; i++ )
142         {
143             _Thread * th_ptr = new _Thread();
144             th_ptr->auto_delete = false;
145             _thread_arr.push_back(th_ptr);
146         }
147     }
148     void start( void )
149     {
150         thread_array::iterator it;
151         for ( it = _thread_arr.begin(); it != _thread_arr.end(); it++ )
152         {
153             (*it)->start();
154         }
155     }
156     void pause( void )
157     {
158         thread_array::iterator it;
159         for ( it = _thread_arr.begin(); it != _thread_arr.end(); it++ )
160         {
161             (*it)->pause();
162         }
163     }
164     void close( void )
165     {
166         thread_array::iterator it;
167         for ( it = _thread_arr.begin(); it != _thread_arr.end(); it++ )
168         {
169             (*it)->close();
170         }
171     }
172     void wait( unsigned long ms = INFINITE )
173     {
174         int count = _thread_arr.size();
175         assert( count <= MAXIMUM_WAIT_OBJECTS );
176         HANDLE * th_hs = new HANDLE[count];
177         int i;
178         for ( i = 0; i < count; ++i )
179         {
180             th_hs[i] = (HANDLE)_thread_arr[i]->handle();
181         }
182         WaitForMultipleObjects( count, th_hs, TRUE, ms );
183         delete [] th_hs;
184     }
185 private:
186     thread_array _thread_arr;
187
188     ThreadManager( ThreadManager const & );
189     ThreadManager & operator = ( ThreadManager const & );
190 };
191
192 // Lock.h -----------------------------------------------------
193 /* 临界区锁 */
194 class CriticalSection
195 {
196 public:
197     CriticalSection( void );
198     ~CriticalSection( void );
199     void lock( void );
200     void unlock( void );
201     bool trylock( void );
202 private:
203     CRITICAL_SECTION _cs;
204
205     CriticalSection( CriticalSection const & );
206     CriticalSection & operator = ( CriticalSection const & );
207 };
208
209 // Lock.cpp -----------------------------------------------------
210 CriticalSection::CriticalSection( void )
211 {
212     ZeroMemory( &_cs, sizeof(_cs) );
213     InitializeCriticalSection(&_cs);
214 }
215
216 CriticalSection::~CriticalSection( void )
217 {
218     DeleteCriticalSection(&_cs);
219 }
220
221 void CriticalSection::lock( void )
222 {
223     EnterCriticalSection(&_cs);
224 }
225
226 void CriticalSection::unlock( void )
227 {
228     LeaveCriticalSection(&_cs);
229 }
230
231 bool CriticalSection::trylock( void )
232 {
233     return TryEnterCriticalSection(&_cs);
234 }
235
236 // Test.cpp --------------------------------------------------------
237 /*自定义一个线程*/
238 class MyThread : public Thread
239 {
240 public:
241     MyThread( CriticalSection * cs_lock ) : _cs_lock(cs_lock)
242     {
243     }
244     MyThread( CriticalSection * cs_lock, std::string name ) :  _cs_lock(cs_lock), _name(name)
245     {
246     }
247     virtual void run()
248     {
249         int i = 0;
250         while ( !this->want_stop && i++ < 100 )
251         {
252             _cs_lock->lock();
253             std::cout << _name << " " << this->thread_id << " 正在运行...\n";
254             _cs_lock->unlock();
255         }
256     }
257 private:
258     CriticalSection * _cs_lock;
259     std::string _name;
260 };
261
262
263 int main()
264 {
265     std::string cmd;
266     CriticalSection cs;
267     class MyThreadOnce : public Thread
268     {
269     public:
270         MyThreadOnce( CriticalSection * cs ) : _cs(cs) {}
271         ~MyThreadOnce( void )
272         {
273             _cs->lock();
274             std::cout << this->thread_id << " 析构！\n";
275             _cs->unlock();
276         }
277         virtual void run()
278         {
279             _cs->lock();
280             std::cout << this->thread_id << " 运行完毕！\n";
281             _cs->unlock();
282         }
283     private:
284         CriticalSection * _cs;
285     };
286
287     // 启动一个线程，运行完毕自动析构
288     (new MyThreadOnce(&cs))->start();
289
290     // 管理一组线程，调用create()函数创建线程，可最多传3个参数调用构造函数
291     ThreadManager<MyThread> mgr;
292     mgr.create( 5, &cs );
293     mgr.create( 5, &cs, std::string("Output") );
294     mgr.start();
295
296     // 接受用户输入
297     while ( std::cin >> cmd )
298     {
299         if ( cmd == "stop" )
300         {
301             break;
302         }
303     }
304
305     return 0;
306 }