BOOST 线程完全攻略 - 扩展 - 可被关闭的线程类

本文假设读者已经基本了解boost线程库的使用方法。

boost是个开源工程，线程这一块也在不断完善之中，到现在这个阶段,boost::thread仅仅实现了一个完美的技术框架，但是读者在实际使用中会发现一些新的技术问题：

1.boost::thread::join开启一个线程以后，怎样主动结束子线程？

2.boost线程之间怎样实现消息传递？

作者在这里描述怎样一步步扩展这些功能。

一. Janitor 异常安全处理

  本文的janitor.hpp是针对异常安全处理的封装类，在后面的扩展类里面有使用到，异常安全的目的是为了保证程序的一段事务的完整性，关于异常安全不是本文的重点，感兴趣的话可以参见http://dev.csdn.net/article/6/6883.shtm

1. // janitor.hpp : 安全执行类库
2. //
3. #pragma once
4. #include 
5. template <class T>
6. class RefHolder
7. {
8.         T& ref_;
9. public:
10.         RefHolder(T& ref) : ref_(ref) {}
11.         operator T& () const 
12.         {
13.                 return ref_;
14.         }
15. private:
16.     // Disable assignment - not implemented
17.     RefHolder& operator=(const RefHolder&);
18. };
19. 
    
20. template <class T>
21. inline RefHolder ByRef(T& t)
22. {
23.         return RefHolder(t);
24. }
25. 
    
26. class ScopeGuardImplBase
27. {
28.         ScopeGuardImplBase& operator =(const ScopeGuardImplBase&);
29. protected:
30.         ~ScopeGuardImplBase()
31.         {
32.         }
33.         ScopeGuardImplBase(const ScopeGuardImplBase& other) throw() 
34.                 : dismissed_(other.dismissed_)
35.         {
36.                 other.Dismiss();
37.         }
38.         template <typename J>
39.         static void SafeExecute(J& j) throw() 
40.         {
41.                 if (!j.dismissed_)
42.                         try
43.                         {
44.                                 j.Execute();
45.                         }
46.                         catch(...)
47.                         {
48.                         }
49.         }
50.         
51.         mutable bool dismissed_;
52. public:
53.         ScopeGuardImplBase() throw() : dismissed_(false) 
54.         {
55.         }
56.         void Dismiss() const throw() 
57.         {
58.                 dismissed_ = true;
59.         }
60. };
61. 
    
62. typedef const ScopeGuardImplBase& ScopeGuard;
63. 
    
64. template <typename F>
65. class ScopeGuardImpl0 : public ScopeGuardImplBase
66. {
67. public:
68.         static ScopeGuardImpl0 MakeGuard(F fun)
69.         {
70.                 return ScopeGuardImpl0(fun);
71.         }
72.         ~ScopeGuardImpl0() throw() 
73.         {
74.                 SafeExecute(*this);
75.         }
76.         void Execute() 
77.         {
78.                 fun_();
79.         }
80. protected:
81.         ScopeGuardImpl0(F fun) : fun_(fun) 
82.         {
83.         }
84.         F fun_;
85. };
86. 
    
87. template <typename F> 
88. inline ScopeGuardImpl0 MakeGuard(F fun)
89. {
90.         return ScopeGuardImpl0::MakeGuard(fun);
91. }
92. 
    
93. template <typename F, typename P1>
94. class ScopeGuardImpl1 : public ScopeGuardImplBase
95. {
96. public:
97.         static ScopeGuardImpl1 MakeGuard(F fun, P1 p1)
98.         {
99.                 return ScopeGuardImpl1(fun, p1);
100.         }
101.         ~ScopeGuardImpl1() throw() 
102.         {
103.                 SafeExecute(*this);
104.         }
105.         void Execute()
106.         {
107.                 fun_(p1_);
108.         }
109. protected:
110.         ScopeGuardImpl1(F fun, P1 p1) : fun_(fun), p1_(p1) 
111.         {
112.         }
113.         F fun_;
114.         const P1 p1_;
115. };
116. 
     
117. template <typename F, typename P1> 
118. inline ScopeGuardImpl1 MakeGuard(F fun, P1 p1)
119. {
120.         return ScopeGuardImpl1::MakeGuard(fun, p1);
121. }
122. 
     
123. template <typename F, typename P1, typename P2>
124. class ScopeGuardImpl2: public ScopeGuardImplBase
125. {
126. public:
127.         static ScopeGuardImpl2 MakeGuard(F fun, P1 p1, P2 p2)
128.         {
129.                 return ScopeGuardImpl2(fun, p1, p2);
130.         }
131.         ~ScopeGuardImpl2() throw() 
132.         {
133.                 SafeExecute(*this);
134.         }
135.         void Execute()
136.         {
137.                 fun_(p1_, p2_);
138.         }
139. protected:
140.         ScopeGuardImpl2(F fun, P1 p1, P2 p2) : fun_(fun), p1_(p1), p2_(p2) 
141.         {
142.         }
143.         F fun_;
144.         const P1 p1_;
145.         const P2 p2_;
146. };
147. 
     
148. template <typename F, typename P1, typename P2>
149. inline ScopeGuardImpl2 MakeGuard(F fun, P1 p1, P2 p2)
150. {
151.         return ScopeGuardImpl2::MakeGuard(fun, p1, p2);
152. }
153. 
     
154. template <typename F, typename P1, typename P2, typename P3>
155. class ScopeGuardImpl3 : public ScopeGuardImplBase
156. {
157. public:
158.         static ScopeGuardImpl3 MakeGuard(F fun, P1 p1, P2 p2, P3 p3)
159.         {
160.                 return ScopeGuardImpl3(fun, p1, p2, p3);
161.         }
162.         ~ScopeGuardImpl3() throw() 
163.         {
164.                 SafeExecute(*this);
165.         }
166.         void Execute()
167.         {
168.                 fun_(p1_, p2_, p3_);
169.         }
170. protected:
171.         ScopeGuardImpl3(F fun, P1 p1, P2 p2, P3 p3) : fun_(fun), p1_(p1), p2_(p2), p3_(p3) 
172.         {
173.         }
174.         F fun_;
175.         const P1 p1_;
176.         const P2 p2_;
177.         const P3 p3_;
178. };
179. 
     
180. template <typename F, typename P1, typename P2, typename P3>
181. inline ScopeGuardImpl3 MakeGuard(F fun, P1 p1, P2 p2, P3 p3)
182. {
183.         return ScopeGuardImpl3::MakeGuard(fun, p1, p2, p3);
184. }
185. 
     
186. //************************************************************
187. 
     
188. template <class Obj, typename MemFun>
189. class ObjScopeGuardImpl0 : public ScopeGuardImplBase
190. {
191. public:
192.         static ObjScopeGuardImpl0 MakeObjGuard(Obj& obj, MemFun memFun)
193.         {
194.                 return ObjScopeGuardImpl0(obj, memFun);
195.         }
196.         ~ObjScopeGuardImpl0() throw() 
197.         {
198.                 SafeExecute(*this);
199.         }
200.         void Execute() 
201.         {
202.                 (obj_.*memFun_)();
203.         }
204. protected:
205.         ObjScopeGuardImpl0(Obj& obj, MemFun memFun) 
206.                 : obj_(obj), memFun_(memFun) {}
207.         Obj& obj_;
208.         MemFun memFun_;
209. };
210. 
     
211. template <class Obj, typename MemFun>
212. inline ObjScopeGuardImpl0 MakeObjGuard(Obj& obj, MemFun memFun)
213. {
214.         return ObjScopeGuardImpl0::MakeObjGuard(obj, memFun);
215. }
216. 
     
217. template <class Obj, typename MemFun, typename P1>
218. class ObjScopeGuardImpl1 : public ScopeGuardImplBase
219. {
220. public:
221.         static ObjScopeGuardImpl1 MakeObjGuard(Obj& obj, MemFun memFun, P1 p1)
222.         {
223.                 return ObjScopeGuardImpl1(obj, memFun, p1);
224.         }
225.         ~ObjScopeGuardImpl1() throw() 
226.         {
227.                 SafeExecute(*this);
228.         }
229.         void Execute() 
230.         {
231.                 (obj_.*memFun_)(p1_);
232.         }
233. protected:
234.         ObjScopeGuardImpl1(Obj& obj, MemFun memFun, P1 p1) 
235.                 : obj_(obj), memFun_(memFun), p1_(p1) {}
236.         Obj& obj_;
237.         MemFun memFun_;
238.         const P1 p1_;
239. };
240. 
     
241. template <class Obj, typename MemFun, typename P1>
242. inline ObjScopeGuardImpl1 MakeObjGuard(Obj& obj, MemFun memFun, P1 p1)
243. {
244.         return ObjScopeGuardImpl1::MakeObjGuard(obj, memFun, p1);
245. }
246. 
     
247. template <class Obj, typename MemFun, typename P1, typename P2>
248. class ObjScopeGuardImpl2 : public ScopeGuardImplBase
249. {
250. public:
251.         static ObjScopeGuardImpl2 MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2)
252.         {
253.                 return ObjScopeGuardImpl2(obj, memFun, p1, p2);
254.         }
255.         ~ObjScopeGuardImpl2() throw() 
256.         {
257.                 SafeExecute(*this);
258.         }
259.         void Execute() 
260.         {
261.                 (obj_.*memFun_)(p1_, p2_);
262.         }
263. protected:
264.         ObjScopeGuardImpl2(Obj& obj, MemFun memFun, P1 p1, P2 p2) 
265.                 : obj_(obj), memFun_(memFun), p1_(p1), p2_(p2) {}
266.         Obj& obj_;
267.         MemFun memFun_;
268.         const P1 p1_;
269.         const P2 p2_;
270. };
271. 
     
272. template <class Obj, typename MemFun, typename P1, typename P2>
273. inline ObjScopeGuardImpl2 MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2)
274. {
275.         return ObjScopeGuardImpl2::MakeObjGuard(obj, memFun, p1, p2);
276. }
277. 
     
278. #define CONCATENATE_DIRECT(s1, s2) s1##s2
279. #define CONCATENATE(s1, s2) CONCATENATE_DIRECT(s1, s2)
280. #define ANONYMOUS_VARIABLE(str) CONCATENATE(str, __LINE__)
281. 
     
282. #define ON_BLOCK_EXIT ScopeGuard ANONYMOUS_VARIABLE(scopeGuard) = MakeGuard
283. #define ON_BLOCK_EXIT_OBJ ScopeGuard ANONYMOUS_VARIABLE(scopeGuard) = MakeObjGuard
284. 
     
285. 
     
286. 
     
287. //////////////////////////////////////////////////////////////////////////////////////////
288. //      janitor
289. struct ICmd_
290. {
291.         virtual void Dismiss() const throw() = 0;
292.         virtual ~ICmd_() throw() {}
293. };
294. 
     
295. template<typename T>
296. class CmdAdaptor : public ICmd_, protected T
297. {
298. public:
299.         template<typename Fun>
300.                 CmdAdaptor(Fun fun) : T(fun) {}
301.         template<typename Fun, typename P1>
302.                 CmdAdaptor(Fun fun, P1 p1) : T(fun, p1) {}
303.         template<typename Fun, typename P1, typename P2>
304.                 CmdAdaptor(Fun fun, P1 p1, P2 p2) : T(fun, p1, p2) {}
305.         template<typename Fun, typename P1, typename P2, typename P3>
306.                 CmdAdaptor(Fun fun, P1 p1, P2 p2, P3 p3) : T(fun, p1, p2, p3) {}
307.         void Dismiss() const throw()
308.         {
309.                 T::Dismiss();
310.         }
311. };
312. 
     
313. class Janitor
314. {
315. public:
316.         Janitor() throw() {}
317.         template <typename F>
318.                 Janitor(F pFun) : spCmd_(
319.                 new CmdAdaptor >(pFun)) {}
320.         template <typename F, typename P1>
321.                 Janitor(F pFun, P1 p1) : spCmd_(
322.                 new CmdAdaptor >(pFun, p1)) {}
323.         template <typename F, typename P1, typename P2>
324.                 Janitor(F pFun, P1 p1, P2 p2) : spCmd_(
325.                 new CmdAdaptor >(pFun, p1, p2)) {}
326.         template <typename F, typename P1, typename P2, typename P3>
327.                 Janitor(F pFun, P1 p1, P2 p2, P3 p3) : spCmd_(
328.                 new CmdAdaptor >(pFun, p1, p2, p3)) {}
329. 
     
330.         Janitor(const Janitor& other) throw() : spCmd_(other.spCmd_) {} //VC++, Comeau need it!
331.         Janitor& operator =(const Janitor& other) throw()
332.         {
333.                 if (spCmd_.get())
334.                         spCmd_->Dismiss();
335.                 spCmd_ = other.spCmd_;
336.                 return *this;
337.         }
338.         void Dismiss() const throw()
339.         {
340.                 spCmd_->Dismiss();
341.         }
342. protected:
343.         mutable std::auto_ptr spCmd_;
344. };
345. 
     
346. template<typename T>
347. class ObjCmdAdaptor : public ICmd_, protected T
348. {
349. public:
350.         template<typename Obj, typename MemFun>
351.                 ObjCmdAdaptor(Obj& obj, MemFun memFun) : T(obj, memFun) {}
352.         template<typename Obj, typename MemFun, typename P1>
353.                 ObjCmdAdaptor(Obj& obj, MemFun memFun, P1 p1) : T(obj, memFun, p1) {}
354.         template<typename Obj, typename MemFun, typename P1, typename P2>
355.                 ObjCmdAdaptor(Obj& obj, MemFun memFun, P1 p1, P2 p2) : T(obj, memFun, p1, p2) {}
356.         void Dismiss() const throw()
357.         {
358.                 T::Dismiss();
359.         }
360. };
361. 
     
362. class ObjJanitor : protected Janitor
363. {
364. public:
365.         using Janitor::Dismiss;
366.         ObjJanitor() throw() {}
367. 
     
368.         template <typename Obj, typename MemFun>
369.                 ObjJanitor(Obj& obj, MemFun memFun)
370.         {
371.                 std::auto_ptr spTmp(
372.                         new ObjCmdAdaptor >(obj, memFun));
373.                 spCmd_ = spTmp;
374.         }
375.         template <typename Obj, typename MemFun, typename P1>
376.                 ObjJanitor(Obj& obj, MemFun memFun, P1 p1)
377.         {
378.                 std::auto_ptr spTmp(
379.                         new ObjCmdAdaptor >(obj, memFun, p1));
380.                 spCmd_ = spTmp;
381.         }
382.         template <typename Obj, typename MemFun, typename P1, typename P2>
383.                 ObjJanitor(Obj& obj, MemFun memFun, P1 p1, P2 p2)
384.         {
385.                 std::auto_ptr spTmp(
386.                         new ObjCmdAdaptor >(obj, memFun, p1, p2));
387.                 spCmd_ = spTmp;
388.         }
389. };
390. 
     
391. 
     

使用范例

1. 
   
2. #include "stdafx.h"
3. #include 
4. #include 
5. using namespace std;
6. 
   
7. #include "janitor.hpp"
8. class class1
9. {
10. public:
11.     class1()
12.     {
13.     }
14.     ~class1()
15.     {
16.     }
17. public:
18.     void test()
19.     {
20.         ObjJanitor ja(*this,&class1::testJanitor);
21.     }
22.     void testJanitor()
23.     {
24.         cout << "hello world" << endl;
25.     }
26. };
27. 
    
28. int _tmain(int argc, _TCHAR* argv[])
29. {
30.     class1 c;
31.     c.test();
32.     return 0;
33. }
34. 
    
35. 
    

二.controlled_module 可被关闭的线程类

 该类原型来自于一个叫“阿修罗”的原始类

1. // controlled_module.hpp : 可主动关闭的boost线程类
2. //
3. #pragma once
4. 
   
5. #include      
6. #include      
7. #include   
8. #include 
9. #include 
10. 
    
11. #include "janitor.hpp"
12. 
    
13. class   controlled_module_implement   :   boost::noncopyable   {   
14.   public:   
15.   controlled_module_implement()   :active_(false),command_exit_(false){}   
16.   boost::condition   module_is_exit;   
17.   boost::mutex   monitor;   
18.   void   active(bool   ac)   
19.   {boost::mutex::scoped_lock   lk(monitor);   if(!(active_=ac))module_is_exit.notify_all();else   command_exit_=false;}   
20.   bool   command_exit(){boost::mutex::scoped_lock   lk(monitor);   return   command_exit_;}   
21.   bool   active_,command_exit_;   
22.     
23.   };
24.   class   controlled_module   :   boost::noncopyable   {   
25.   public:   
26.   virtual   void   run()
27.   {
28.       ObjJanitor   janitor(*impl_,&controlled_module_implement::active,false);   
29.     impl_->active(true);   
30.     {   
31.         ObjJanitor   janitor(*this,&controlled_module::release);   
32.         if(this->initialize())   
33.         {   
34.             m_live = true;
35.             SetEvent(m_event_init);
36.             while(!impl_->command_exit()   &&  this->islive() &&  this->work())
37.             {
38.             }
39.         }
40.         else
41.         {
42.             m_live = false;
43.             SetEvent(m_event_init);
44.         }
45.     }  
46.   }
47.   bool   exit(unsigned   long   sec=0)
48.   {
49.   boost::mutex::scoped_lock   lk(impl_->monitor);   
50.   impl_->command_exit_   =   true;   
51.   while(impl_->active_)   
52.   {   
53.   if(sec)   
54.   {   
55.   boost::xtime   xt;   
56.   boost::xtime_get(&xt,   boost::TIME_UTC);   
57.   xt.sec   +=   sec;   
58.   if(!impl_->module_is_exit.timed_wait(lk,xt))   
59.   return   false;   
60.   }   
61.   else   
62.   impl_->module_is_exit.wait(lk);   
63.   }   
64.   return   true;   
65.   }
66.   protected:   
67.   controlled_module()
68.   :impl_(new   controlled_module_implement)   
69.   ,m_live(false)
70.   ,m_event_init(0)
71.   ,m_sleeptime(10)
72.   {     
73.   }   
74.   virtual   ~controlled_module()
75.   {
76.       if(m_live)
77.           stop();
78.       delete   impl_;   
79.   }
80.   private:    
81.       virtual   bool   initialize(){return true;} 
82.       virtual   void   release(){}
83.   protected:
84.       virtual   bool   work()
85.       {
86.         Sleep(this->m_sleeptime);
87.         return true;
88.       }
89.       int m_sleeptime;
90.   private:   
91.     bool m_live;
92.     void * m_event_init;
93.  controlled_module_implement*   impl_;   
94.   public:
95.     bool start()
96.     {
97.         m_event_init = CreateEvent(NULL,FALSE,FALSE,"");
98.         boost::thread thd(boost::bind(&controlled_module::run,this));
99.         ::WaitForSingleObject(m_event_init,INFINITE);
100.         CloseHandle(m_event_init);
101.         m_event_init = 0;
102.         return m_live;
103.     }
104.     void stop()
105.     {
106.         m_live = false;
107.         exit(1);
108.     }
109.     bool islive(){return m_live;}
110.     void die()
111.     {
112.       m_live = false;
113.         SetEvent(m_event_init);
114.     }
115.     void setsleeptime(int n)
116.     {
117.       m_sleeptime = n;
118.     }
119.   };
120.     
121. 
     
122. 
     

  virtual   bool   initialize();   初始化

  virtual   void   release();   释放

  virtual   bool   work();   工作函数

  如果我们要创建一个可被关闭的线程，可以如下步骤：

  1）创建一个controlled_module 继承类

  2）实现3个虚拟函数

  3）用start(),stop()启动和停止线程

范例：

1. //controlled_module demo
2. #include "controlled_module.hpp"
3. class thd: public controlled_module
4. {
5. public:
6.     virtual bool initialize()
7.     {
8.         cout << "thd init" << endl;
9.         return true;
10.     }
11.     virtual void release()
12.     {
13.         cout << "thd release" << endl;
14.     }
15.     virtual bool work()
16.     {
17.         //your work........
18.         return controlled_module::work();
19.     }
20. };
21. int _tmain(int argc, _TCHAR* argv[])
22. {
23.     thd t;
24.     t.start();
25.     char buf[10];
26.     gets_s(buf,sizeof buf);
27.     t.stop();
28.     return 0;
29. }
30. 
    
31. 
    

thd线程在启动以后，将循环执行work()函数，直到线程退出