【C/C++开发】C++ Thread对象封装

Pthread库是posix linux的线程库，调用接口如下，我们模仿JDK，对Thread进行封装，具体的业务逻辑只需要如同Thread一样实现run方法即可。

线程操纵函数（简介起见，省略参数）

pthread_create()：创建一个线程

pthread_exit()：终止当前线程

pthread_cancel()：中断另外一个线程的运行

pthread_join()：阻塞当前的线程，直到另外一个线程运行结束

pthread_attr_init()：初始化线程的属性

pthread_attr_setdetachstate()：设置脱离状态的属性（决定这个线程在终止时是否可以被结合）

pthread_attr_getdetachstate()：获取脱离状态的属性

pthread_attr_destroy()：删除线程的属性

pthread_kill()：向 线程发送一个信号

 

 首先，构造一个run接口如下：

class  TC_Runable

{

public :

     virtual  ~TC_Runable(){};

     virtual  void  run() = 0;

};

声明线程基础类：

/**

 * 线程基类.

 * 线程基类，所有自定义线程继承于该类，同时实现run接口即可,   

 * 可以通过TC_ThreadContorl管理线程。

 */

class  TC_Thread  :  public  TC_Runable

{

public :

      /**

     * @brief  构造函数

      */

     TC_Thread();

      /**

     * @brief  析构函数

      */

      virtual  ~TC_Thread(){};

      /**

     * @brief  线程运行

      */

      TC_ThreadControl  start();

     /**

     * @brief  获取线程控制类.

     *

     * @return ThreadControl

     */

     TC_ThreadControl  getThreadControl()  const ;

     /**

     * @brief  线程是否存活.

     *

     * @return bool 存活返回true，否则返回false

     */

     bool  isAlive()  const ;

      /**

     * @brief  获取线程id.

      *

      * @return pthread_t 线程id

      */

     pthread_t id() {  return  _tid ; }

protected :

      /**

      * @brief  静态函数, 线程入口.

      * 

      * @param pThread 线程对象

      */

      static  void  threadEntry( TC_Thread  *pThread);

      /**

     * @brief  运行

      */

     virtual  void  run() = 0;

protected :

     /**

     * 是否在运行

     */

     bool              _running ;

     /**

     * 线程ID

     */

    pthread_t       _tid ;

     /**

     * 线程锁

     */

     TC_ThreadLock     _lock ;

};

根据Pthread提供的接口实现该Thread类。

线程构造函数：

TC_Thread::TC_Thread() :  _running (  false ),  _tid (-1)

{

}

初始化tid为-1，线程状态running为false。

线程执行入口，该方法声明的时候必须为静态方法，因为该方法符合pthread_create方法中的函数指针的类型，该方法将会回调thread的具体的子类 重载 的run方法，thread子类的实例通过指针传递进来。

void  TC_Thread::threadEntry(  TC_Thread  *pThread)

{

    pThread-> _running  =  true ;

    {

         TC_ThreadLock :: Lock  sync(pThread->  _lock );

        pThread->  _lock .notifyAll();

    }

     try

    {

        pThread->run();

    }

     catch (...)

    {

        pThread->  _running  =  false ;

         throw ;

    }

    pThread-> _running  =  false ;

}

通过调用start方法线程开始执行，但并不负责具体的执行逻辑，所以该方法对于start来说是通过的，是调用pthread_ctreat的地方，在该方法中，会调用this.threadEntity函数，通过其回调this.run()

TC_ThreadControl  TC_Thread::start()

{

     TC_ThreadLock :: Lock  sync( _lock );

     if ( _running )

    {

         throw  TC_ThreadThreadControl_Exception ( "[TC_Thread::start] thread has start" );

    }

     int  ret = pthread_create(& _tid  ,

                   0,

                   (  void  *(*)(  void  *))& threadEntry,

                   (  void  *)  this );

     if (ret != 0)

    {

         throw  TC_ThreadThreadControl_Exception ( "[TC_Thread::start] thread start error" , ret);

    }

     _lock .wait();

     return  TC_ThreadControl ( _tid );

}

获取线程控制工具类

TC_ThreadControl  TC_Thread::getThreadControl ()  const

{

     return  TC_ThreadControl ( _tid );

}

判断线程当前状态。

bool  TC_Thread::isAlive()  const

{

     return  _running ;

}

整个线程类封装设计的难点在于，如果保证running的同步，我们必须保证线程真正在执行run方法的时候，该running设置为true，也就是说不能单纯的在start中变更该状态，因为此时有可能threadEntity并没有被执行（Pthread_creat）

在start方法中，首先便获取锁并顺序执行，但是start方法并不返回将wait住（3）（因为此事线程提方法并不一定成功执行，也就是说start能够返回的标志是该线程状态必须为running，否则在业务层面执行完start方法紧接着判断线程isalive却返回false会给调用者带来迷茫，甚至导致重复启动），threadEntity执行时表明pthread_create方法已经开始执行了，新线程执行OK，此时该方法将running设置为true（1），并且试图获取锁，此时如果wait已经执行，则获取锁操作可以成功，如果wait不成功，则会阻塞在这里等待wait操作的到来释放锁。

    {

         TC_ThreadLock :: Lock  sync(pThread->  _lock );

        pThread->  _lock .notifyAll();

    }

这个大括号很重要，表示sync的生命周期在大括号结束的时候会释放，锁释放代表着notifyAll生效（真正的通知wait解除阻塞是在锁释放的时候进行的，因为wait需要重新获取锁），此时running为true，start方法可以安全返回了。当方法进行完之后，将running重新设置为false（2）。