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 <list>
  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. };
  20. template <class T>
  21. inline RefHolder<T> ByRef(T& t)
  22. {
  23.         return RefHolder<T>(t);
  24. }
  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. };
  62. typedef const ScopeGuardImplBase& ScopeGuard;
  64. template <typename F>
  65. class ScopeGuardImpl0 : public ScopeGuardImplBase
  66. {
  67. public:
  68.         static ScopeGuardImpl0<F> MakeGuard(F fun)
  69.         {
  70.                 return ScopeGuardImpl0<F>(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. };
  87. template <typename F> 
  88. inline ScopeGuardImpl0<F> MakeGuard(F fun)
  89. {
  90.         return ScopeGuardImpl0<F>::MakeGuard(fun);
  91. }
  93. template <typename F, typename P1>
  94. class ScopeGuardImpl1 : public ScopeGuardImplBase
  95. {
  96. public:
  97.         static ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1)
  98.         {
  99.                 return ScopeGuardImpl1<F, P1>(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. };
  117. template <typename F, typename P1> 
  118. inline ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1)
  119. {
  120.         return ScopeGuardImpl1<F, P1>::MakeGuard(fun, p1);
  121. }
  123. template <typename F, typename P1, typename P2>
  124. class ScopeGuardImpl2: public ScopeGuardImplBase
  125. {
  126. public:
  127.         static ScopeGuardImpl2<F, P1, P2> MakeGuard(F fun, P1 p1, P2 p2)
  128.         {
  129.                 return ScopeGuardImpl2<F, P1, P2>(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. };
  148. template <typename F, typename P1, typename P2>
  149. inline ScopeGuardImpl2<F, P1, P2> MakeGuard(F fun, P1 p1, P2 p2)
  150. {
  151.         return ScopeGuardImpl2<F, P1, P2>::MakeGuard(fun, p1, p2);
  152. }
  154. template <typename F, typename P1, typename P2, typename P3>
  155. class ScopeGuardImpl3 : public ScopeGuardImplBase
  156. {
  157. public:
  158.         static ScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3)
  159.         {
  160.                 return ScopeGuardImpl3<F, P1, P2, P3>(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. };
  180. template <typename F, typename P1, typename P2, typename P3>
  181. inline ScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3)
  182. {
  183.         return ScopeGuardImpl3<F, P1, P2, P3>::MakeGuard(fun, p1, p2, p3);
  184. }
  186. //************************************************************
  188. template <class Obj, typename MemFun>
  189. class ObjScopeGuardImpl0 : public ScopeGuardImplBase
  190. {
  191. public:
  192.         static ObjScopeGuardImpl0<Obj, MemFun> MakeObjGuard(Obj& obj, MemFun memFun)
  193.         {
  194.                 return ObjScopeGuardImpl0<Obj, MemFun>(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. };
  211. template <class Obj, typename MemFun>
  212. inline ObjScopeGuardImpl0<Obj, MemFun> MakeObjGuard(Obj& obj, MemFun memFun)
  213. {
  214.         return ObjScopeGuardImpl0<Obj, MemFun>::MakeObjGuard(obj, memFun);
  215. }
  217. template <class Obj, typename MemFun, typename P1>
  218. class ObjScopeGuardImpl1 : public ScopeGuardImplBase
  219. {
  220. public:
  221.         static ObjScopeGuardImpl1<Obj, MemFun, P1> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1)
  222.         {
  223.                 return ObjScopeGuardImpl1<Obj, MemFun, P1>(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. };
  241. template <class Obj, typename MemFun, typename P1>
  242. inline ObjScopeGuardImpl1<Obj, MemFun, P1> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1)
  243. {
  244.         return ObjScopeGuardImpl1<Obj, MemFun, P1>::MakeObjGuard(obj, memFun, p1);
  245. }
  247. template <class Obj, typename MemFun, typename P1, typename P2>
  248. class ObjScopeGuardImpl2 : public ScopeGuardImplBase
  249. {
  250. public:
  251.         static ObjScopeGuardImpl2<Obj, MemFun, P1, P2> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2)
  252.         {
  253.                 return ObjScopeGuardImpl2<Obj, MemFun, P1, P2>(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. };
  272. template <class Obj, typename MemFun, typename P1, typename P2>
  273. inline ObjScopeGuardImpl2<Obj, MemFun, P1, P2> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2)
  274. {
  275.         return ObjScopeGuardImpl2<Obj, MemFun, P1, P2>::MakeObjGuard(obj, memFun, p1, p2);
  276. }
  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__)
  282. #define ON_BLOCK_EXIT ScopeGuard ANONYMOUS_VARIABLE(scopeGuard) = MakeGuard
  283. #define ON_BLOCK_EXIT_OBJ ScopeGuard ANONYMOUS_VARIABLE(scopeGuard) = MakeObjGuard
  287. //////////////////////////////////////////////////////////////////////////////////////////
  288. //      janitor
  289. struct ICmd_
  290. {
  291.         virtual void Dismiss() const throw() = 0;
  292.         virtual ~ICmd_() throw() {}
  293. };
  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. };
  313. class Janitor
  314. {
  315. public:
  316.         Janitor() throw() {}
  317.         template <typename F>
  318.                 Janitor(F pFun) : spCmd_(
  319.                 new CmdAdaptor<ScopeGuardImpl0<F> >(pFun)) {}
  320.         template <typename F, typename P1>
  321.                 Janitor(F pFun, P1 p1) : spCmd_(
  322.                 new CmdAdaptor<ScopeGuardImpl1<F, P1> >(pFun, p1)) {}
  323.         template <typename F, typename P1, typename P2>
  324.                 Janitor(F pFun, P1 p1, P2 p2) : spCmd_(
  325.                 new CmdAdaptor<ScopeGuardImpl2<F, P1, P2> >(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<ScopeGuardImpl3<F, P1, P2, P3> >(pFun, p1, p2, p3)) {}
  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<ICmd_> spCmd_;
  344. };
  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. };
  362. class ObjJanitor : protected Janitor
  363. {
  364. public:
  365.         using Janitor::Dismiss;
  366.         ObjJanitor() throw() {}
  368.         template <typename Obj, typename MemFun>
  369.                 ObjJanitor(Obj& obj, MemFun memFun)
  370.         {
  371.                 std::auto_ptr<ICmd_> spTmp(
  372.                         new ObjCmdAdaptor<ObjScopeGuardImpl0<Obj, MemFun> >(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<ICmd_> spTmp(
  379.                         new ObjCmdAdaptor<ObjScopeGuardImpl1<Obj, MemFun, P1> >(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<ICmd_> spTmp(
  386.                         new ObjCmdAdaptor<ObjScopeGuardImpl2<Obj, MemFun, P1, P2> >(obj, memFun, p1, p2));
  387.                 spCmd_ = spTmp;
  388.         }
  389. };
使用范例
  2. #include "stdafx.h"
  3. #include <iostream>
  4. #include <string>
  5. using namespace std;
  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. };
  28. int _tmain(int argc, _TCHAR* argv[])
  29. {
  30.     class1 c;
  31.     c.test();
  32.     return 0;
  33. }
二.controlled_module 可被关闭的线程类
 该类原型来自于一个叫“阿修罗”的原始类
  1. // controlled_module.hpp : 可主动关闭的boost线程类
  2. //
  3. #pragma once
  5. #include   <boost/utility.hpp>   
  6. #include   <boost/thread/condition.hpp>   
  7. #include   <boost/thread/mutex.hpp>
  8. #include <boost/thread/thread.hpp>
  9. #include <boost/bind.hpp>
  11. #include "janitor.hpp"
  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.     
  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. }
thd线程在启动以后，将循环执行work()函数，直到线程退出
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/lvdongjie/p/4447785.html