支持HW团队,就支付宝领取下面的红包吧!(2018年3月31前,就几毛,也会几块,可以和其他红包叠加使用),你领取消费,HW有奖励。红包使用无条件限制,有条件请注意是不是有病毒。

小伙伴们,给大家发红包喽!人人可领,领完就能用。祝大家领取的红包金额大大大!#吱口令#长按复制此消息,打开支付宝就能领取!er1OEj73Uj

登入 注册 | 验证
| 搜索

博主:初学MPEG

初学MPEG 本博客-采用Python的web框架Django与Mysql数据库,致力于对Python、Django的了解 与研究
Django技术QQ群:XXXXXXX
Python技术QQ群:XXXXXXX

分类

关键字

本站最新博文

友情链接  

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

类别:STL、Boost 状态:游客可见,可回,自己可关联(良好) 阅读:4770 评论:0 时间:四月 12, 2012, 9:48 a.m.
关键字: boost Thread

 来源:http://blog.csdn.net/iamnieo/article/details/2908841
本文假设读者已经基本了解boost线程库的使用方法。

boost是个开源工程,线程这一块也在不断完善之中,到现在这个阶段,boost::thread仅仅实现了一个完美的技术框架,但是读者在实际使用中会发现一些新的技术问题:
1.boost::thread::join开启一个线程以后,怎样主动结束子线程?
2.boost线程之间怎样实现消息传递?
作者在这里描述怎样一步步扩展这些功能。
 
一. Janitor 异常安全处理
  本文的janitor.hpp是针对异常安全处理的封装类,在后面的扩展类里面有使用到,异常安全的目的是为了保证程序的一段事务的完整性,关于异常安全不是本文的重点,感兴趣的话可以参见http://dev.csdn.net/article/6/6883.shtm(已经无效)
// janitor.hpp : 安全执行类库
//
#pragma once
#include <list>
template <class T>
class RefHolder
{
        T& ref_;
public:
        RefHolder(T& ref) : ref_(ref) {}
        operator T& () const 
        {
                return ref_;
        }
private:
    // Disable assignment - not implemented
    RefHolder& operator=(const RefHolder&);
};
 
template <class T>
inline RefHolder<T> ByRef(T& t)
{
        return RefHolder<T>(t);
}
 
class ScopeGuardImplBase
{
        ScopeGuardImplBase& operator =(const ScopeGuardImplBase&);
protected:
        ~ScopeGuardImplBase()
        {
        }
        ScopeGuardImplBase(const ScopeGuardImplBase& other) throw() 
                : dismissed_(other.dismissed_)
        {
                other.Dismiss();
        }
        template <typename J>
        static void SafeExecute(J& j) throw() 
        {
                if (!j.dismissed_)
                        try
                        {
                                j.Execute();
                        }
                        catch(...)
                        {
                        }
        }
        
        mutable bool dismissed_;
public:
        ScopeGuardImplBase() throw() : dismissed_(false) 
        {
        }
        void Dismiss() const throw() 
        {
                dismissed_ = true;
        }
};
 
typedef const ScopeGuardImplBase& ScopeGuard;
 
template <typename F>
class ScopeGuardImpl0 : public ScopeGuardImplBase
{
public:
        static ScopeGuardImpl0<F> MakeGuard(F fun)
        {
                return ScopeGuardImpl0<F>(fun);
        }
        ~ScopeGuardImpl0() throw() 
        {
                SafeExecute(*this);
        }
        void Execute() 
        {
                fun_();
        }
protected:
        ScopeGuardImpl0(F fun) : fun_(fun) 
        {
        }
        F fun_;
};
 
template <typename F> 
inline ScopeGuardImpl0<F> MakeGuard(F fun)
{
        return ScopeGuardImpl0<F>::MakeGuard(fun);
}
 
template <typename F, typename P1>
class ScopeGuardImpl1 : public ScopeGuardImplBase
{
public:
        static ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1)
        {
                return ScopeGuardImpl1<F, P1>(fun, p1);
        }
        ~ScopeGuardImpl1() throw() 
        {
                SafeExecute(*this);
        }
        void Execute()
        {
                fun_(p1_);
        }
protected:
        ScopeGuardImpl1(F fun, P1 p1) : fun_(fun), p1_(p1) 
        {
        }
        F fun_;
        const P1 p1_;
};
 
template <typename F, typename P1> 
inline ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1)
{
        return ScopeGuardImpl1<F, P1>::MakeGuard(fun, p1);
}
 
template <typename F, typename P1, typename P2>
class ScopeGuardImpl2: public ScopeGuardImplBase
{
public:
        static ScopeGuardImpl2<F, P1, P2> MakeGuard(F fun, P1 p1, P2 p2)
        {
                return ScopeGuardImpl2<F, P1, P2>(fun, p1, p2);
        }
        ~ScopeGuardImpl2() throw() 
        {
                SafeExecute(*this);
        }
        void Execute()
        {
                fun_(p1_, p2_);
        }
protected:
        ScopeGuardImpl2(F fun, P1 p1, P2 p2) : fun_(fun), p1_(p1), p2_(p2) 
        {
        }
        F fun_;
        const P1 p1_;
        const P2 p2_;
};
 
template <typename F, typename P1, typename P2>
inline ScopeGuardImpl2<F, P1, P2> MakeGuard(F fun, P1 p1, P2 p2)
{
        return ScopeGuardImpl2<F, P1, P2>::MakeGuard(fun, p1, p2);
}
 
template <typename F, typename P1, typename P2, typename P3>
class ScopeGuardImpl3 : public ScopeGuardImplBase
{
public:
        static ScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3)
        {
                return ScopeGuardImpl3<F, P1, P2, P3>(fun, p1, p2, p3);
        }
        ~ScopeGuardImpl3() throw() 
        {
                SafeExecute(*this);
        }
        void Execute()
        {
                fun_(p1_, p2_, p3_);
        }
protected:
        ScopeGuardImpl3(F fun, P1 p1, P2 p2, P3 p3) : fun_(fun), p1_(p1), p2_(p2), p3_(p3) 
        {
        }
        F fun_;
        const P1 p1_;
        const P2 p2_;
        const P3 p3_;
};
 
template <typename F, typename P1, typename P2, typename P3>
inline ScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3)
{
        return ScopeGuardImpl3<F, P1, P2, P3>::MakeGuard(fun, p1, p2, p3);
}
 
//************************************************************
 
template <class Obj, typename MemFun>
class ObjScopeGuardImpl0 : public ScopeGuardImplBase
{
public:
        static ObjScopeGuardImpl0<Obj, MemFun> MakeObjGuard(Obj& obj, MemFun memFun)
        {
                return ObjScopeGuardImpl0<Obj, MemFun>(obj, memFun);
        }
        ~ObjScopeGuardImpl0() throw() 
        {
                SafeExecute(*this);
        }
        void Execute() 
        {
                (obj_.*memFun_)();
        }
protected:
        ObjScopeGuardImpl0(Obj& obj, MemFun memFun) 
                : obj_(obj), memFun_(memFun) {}
        Obj& obj_;
        MemFun memFun_;
};
 
template <class Obj, typename MemFun>
inline ObjScopeGuardImpl0<Obj, MemFun> MakeObjGuard(Obj& obj, MemFun memFun)
{
        return ObjScopeGuardImpl0<Obj, MemFun>::MakeObjGuard(obj, memFun);
}
 
template <class Obj, typename MemFun, typename P1>
class ObjScopeGuardImpl1 : public ScopeGuardImplBase
{
public:
        static ObjScopeGuardImpl1<Obj, MemFun, P1> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1)
        {
                return ObjScopeGuardImpl1<Obj, MemFun, P1>(obj, memFun, p1);
        }
        ~ObjScopeGuardImpl1() throw() 
        {
                SafeExecute(*this);
        }
        void Execute() 
        {
                (obj_.*memFun_)(p1_);
        }
protected:
        ObjScopeGuardImpl1(Obj& obj, MemFun memFun, P1 p1) 
                : obj_(obj), memFun_(memFun), p1_(p1) {}
        Obj& obj_;
        MemFun memFun_;
        const P1 p1_;
};
 
template <class Obj, typename MemFun, typename P1>
inline ObjScopeGuardImpl1<Obj, MemFun, P1> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1)
{
        return ObjScopeGuardImpl1<Obj, MemFun, P1>::MakeObjGuard(obj, memFun, p1);
}
 
template <class Obj, typename MemFun, typename P1, typename P2>
class ObjScopeGuardImpl2 : public ScopeGuardImplBase
{
public:
        static ObjScopeGuardImpl2<Obj, MemFun, P1, P2> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2)
        {
                return ObjScopeGuardImpl2<Obj, MemFun, P1, P2>(obj, memFun, p1, p2);
        }
        ~ObjScopeGuardImpl2() throw() 
        {
                SafeExecute(*this);
        }
        void Execute() 
        {
                (obj_.*memFun_)(p1_, p2_);
        }
protected:
        ObjScopeGuardImpl2(Obj& obj, MemFun memFun, P1 p1, P2 p2) 
                : obj_(obj), memFun_(memFun), p1_(p1), p2_(p2) {}
        Obj& obj_;
        MemFun memFun_;
        const P1 p1_;
        const P2 p2_;
};
 
template <class Obj, typename MemFun, typename P1, typename P2>
inline ObjScopeGuardImpl2<Obj, MemFun, P1, P2> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2)
{
        return ObjScopeGuardImpl2<Obj, MemFun, P1, P2>::MakeObjGuard(obj, memFun, p1, p2);
}
 
#define CONCATENATE_DIRECT(s1, s2) s1##s2
#define CONCATENATE(s1, s2) CONCATENATE_DIRECT(s1, s2)
#define ANONYMOUS_VARIABLE(str) CONCATENATE(str, __LINE__)
 
#define ON_BLOCK_EXIT ScopeGuard ANONYMOUS_VARIABLE(scopeGuard) = MakeGuard
#define ON_BLOCK_EXIT_OBJ ScopeGuard ANONYMOUS_VARIABLE(scopeGuard) = MakeObjGuard
 
 
 
//////////////////////////////////////////////////////////////////////////////////////////
//      janitor
struct ICmd_
{
        virtual void Dismiss() const throw() = 0;
        virtual ~ICmd_() throw() {}
};
 
template<typename T>
class CmdAdaptor : public ICmd_, protected T
{
public:
        template<typename Fun>
                CmdAdaptor(Fun fun) : T(fun) {}
        template<typename Fun, typename P1>
                CmdAdaptor(Fun fun, P1 p1) : T(fun, p1) {}
        template<typename Fun, typename P1, typename P2>
                CmdAdaptor(Fun fun, P1 p1, P2 p2) : T(fun, p1, p2) {}
        template<typename Fun, typename P1, typename P2, typename P3>
                CmdAdaptor(Fun fun, P1 p1, P2 p2, P3 p3) : T(fun, p1, p2, p3) {}
        void Dismiss() const throw()
        {
                T::Dismiss();
        }
};
 
class Janitor
{
public:
        Janitor() throw() {}
        template <typename F>
                Janitor(F pFun) : spCmd_(
                new CmdAdaptor<ScopeGuardImpl0<F> >(pFun)) {}
        template <typename F, typename P1>
                Janitor(F pFun, P1 p1) : spCmd_(
                new CmdAdaptor<ScopeGuardImpl1<F, P1> >(pFun, p1)) {}
        template <typename F, typename P1, typename P2>
                Janitor(F pFun, P1 p1, P2 p2) : spCmd_(
                new CmdAdaptor<ScopeGuardImpl2<F, P1, P2> >(pFun, p1, p2)) {}
        template <typename F, typename P1, typename P2, typename P3>
                Janitor(F pFun, P1 p1, P2 p2, P3 p3) : spCmd_(
                new CmdAdaptor<ScopeGuardImpl3<F, P1, P2, P3> >(pFun, p1, p2, p3)) {}
 
        Janitor(const Janitor& other) throw() : spCmd_(other.spCmd_) {} //VC++, Comeau need it!
        Janitor& operator =(const Janitor& other) throw()
        {
                if (spCmd_.get())
                        spCmd_->Dismiss();
                spCmd_ = other.spCmd_;
                return *this;
        }
        void Dismiss() const throw()
        {
                spCmd_->Dismiss();
        }
protected:
        mutable std::auto_ptr<ICmd_> spCmd_;
};
 
template<typename T>
class ObjCmdAdaptor : public ICmd_, protected T
{
public:
        template<typename Obj, typename MemFun>
                ObjCmdAdaptor(Obj& obj, MemFun memFun) : T(obj, memFun) {}
        template<typename Obj, typename MemFun, typename P1>
                ObjCmdAdaptor(Obj& obj, MemFun memFun, P1 p1) : T(obj, memFun, p1) {}
        template<typename Obj, typename MemFun, typename P1, typename P2>
                ObjCmdAdaptor(Obj& obj, MemFun memFun, P1 p1, P2 p2) : T(obj, memFun, p1, p2) {}
        void Dismiss() const throw()
        {
                T::Dismiss();
        }
};
 
class ObjJanitor : protected Janitor
{
public:
        using Janitor::Dismiss;
        ObjJanitor() throw() {}
 
        template <typename Obj, typename MemFun>
                ObjJanitor(Obj& obj, MemFun memFun)
        {
                std::auto_ptr<ICmd_> spTmp(
                        new ObjCmdAdaptor<ObjScopeGuardImpl0<Obj, MemFun> >(obj, memFun));
                spCmd_ = spTmp;
        }
        template <typename Obj, typename MemFun, typename P1>
                ObjJanitor(Obj& obj, MemFun memFun, P1 p1)
        {
                std::auto_ptr<ICmd_> spTmp(
                        new ObjCmdAdaptor<ObjScopeGuardImpl1<Obj, MemFun, P1> >(obj, memFun, p1));
                spCmd_ = spTmp;
        }
        template <typename Obj, typename MemFun, typename P1, typename P2>
                ObjJanitor(Obj& obj, MemFun memFun, P1 p1, P2 p2)
        {
                std::auto_ptr<ICmd_> spTmp(
                        new ObjCmdAdaptor<ObjScopeGuardImpl2<Obj, MemFun, P1, P2> >(obj, memFun, p1, p2));
                spCmd_ = spTmp;
        }
};

使用范例

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
 
#include "janitor.hpp"
class class1
{
public:
    class1()
    {
    }
    ~class1()
    {
    }
public:
    void test()
    {
        ObjJanitor ja(*this,&class1::testJanitor);
    }
    void testJanitor()
    {
        cout << "hello world" << endl;
    }
};
 
int _tmain(int argc, _TCHAR* argv[])
{
    class1 c;
    c.test();
    return 0;
}

 

二.controlled_module 可被关闭的线程类
 该类原型来自于一个叫“阿修罗”的原始类
// controlled_module.hpp : 可主动关闭的boost线程类
//
#pragma once
 
#include   <boost/utility.hpp>   
#include   <boost/thread/condition.hpp>   
#include   <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
 
#include "janitor.hpp"
 
class   controlled_module_implement   :   boost::noncopyable   {   
  public:   
  controlled_module_implement()   :active_(false),command_exit_(false){}   
  boost::condition   module_is_exit;   
  boost::mutex   monitor;   
  void   active(bool   ac)   
  {boost::mutex::scoped_lock   lk(monitor);   if(!(active_=ac))module_is_exit.notify_all();else   command_exit_=false;}   
  bool   command_exit(){boost::mutex::scoped_lock   lk(monitor);   return   command_exit_;}   
  bool   active_,command_exit_;   
    
  };
  class   controlled_module   :   boost::noncopyable   {   
  public:   
  virtual   void   run()
  {
      ObjJanitor   janitor(*impl_,&controlled_module_implement::active,false);   
    impl_->active(true);   
    {   
        ObjJanitor   janitor(*this,&controlled_module::release);   
        if(this->initialize())   
        {   
            m_live = true;
            SetEvent(m_event_init);
            while(!impl_->command_exit()   &&  this->islive() &&  this->work())
            {
            }
        }
        else
        {
            m_live = false;
            SetEvent(m_event_init);
        }
    }  
  }
  bool   exit(unsigned   long   sec=0)
  {
  boost::mutex::scoped_lock   lk(impl_->monitor);   
  impl_->command_exit_   =   true;   
  while(impl_->active_)   
  {   
  if(sec)   
  {   
  boost::xtime   xt;   
  boost::xtime_get(&xt,   boost::TIME_UTC);   
  xt.sec   +=   sec;   
  if(!impl_->module_is_exit.timed_wait(lk,xt))   
  return   false;   
  }   
  else   
  impl_->module_is_exit.wait(lk);   
  }   
  return   true;   
  }
  protected:   
  controlled_module()
  :impl_(new   controlled_module_implement)   
  ,m_live(false)
  ,m_event_init(0)
  ,m_sleeptime(10)
  {     
  }   
  virtual   ~controlled_module()
  {
      if(m_live)
          stop();
      delete   impl_;   
  }
  private:    
      virtual   bool   initialize(){return true;} 
      virtual   void   release(){}
  protected:
      virtual   bool   work()
      {
        Sleep(this->m_sleeptime);
        return true;
      }
      int m_sleeptime;
  private:   
    bool m_live;
    void * m_event_init;
 controlled_module_implement*   impl_;   
  public:
    bool start()
    {
        m_event_init = CreateEvent(NULL,FALSE,FALSE,"");
        boost::thread thd(boost::bind(&controlled_module::run,this));
        ::WaitForSingleObject(m_event_init,INFINITE);
        CloseHandle(m_event_init);
        m_event_init = 0;
        return m_live;
    }
    void stop()
    {
        m_live = false;
        exit(1);
    }
    bool islive(){return m_live;}
    void die()
    {
      m_live = false;
        SetEvent(m_event_init);
    }
    void setsleeptime(int n)
    {
      m_sleeptime = n;
    }
  };
  virtual   bool   initialize();   初始化
  virtual   void   release();   释放
  virtual   bool   work();   工作函数
  如果我们要创建一个可被关闭的线程,可以如下步骤:
  1)创建一个controlled_module 继承类
  2)实现3个虚拟函数
  3)用start(),stop()启动和停止线程
范例:
//controlled_module demo
#include "controlled_module.hpp"
class thd: public controlled_module
{
public:
    virtual bool initialize()
    {
        cout << "thd init" << endl;
        return true;
    }
    virtual void release()
    {
        cout << "thd release" << endl;
    }
    virtual bool work()
    {
        //your work........
        return controlled_module::work();
    }
};
int _tmain(int argc, _TCHAR* argv[])
{
    thd t;
    t.start();
    char buf[10];
    gets_s(buf,sizeof buf);
    t.stop();
    return 0;
}
 
 
thd线程在启动以后,将循环执行work()函数,直到线程退出
操作:

Please Login (or Sign Up) to leave a comment