原创 boost库之thread之一

thread 库

对于这个库，大家期待已久。在交互式编程中，没有线程这个东西好多事还真不好办。

thread     <boost/thread.hpp>

一览无余：

class thread
{
public:
       thread();

       template <class F>
       explicit thread(F f);
       template <class F,class A1,class A2,...>
       thread(F f,A1 a1,A2 a2,...);

       class id;
       id get_id() const;

       bool joinable() const;
       void join();
       bool timed_join(const system_time& wait_until);
       template<typename TimeDuration>
       bool timed_join(TimeDuration const& rel_time);
       void detach();

       void interrupt();      //中断部份没搞得太清楚
       bool interruption_requested() const;
       // backwards compatibility
       bool operator==(const thread& other) const;
       bool operator!=(const thread& other) const;
       static void yield();
       static void sleep(const system_time& xt);
};
void swap(thread& lhs,thread& rhs);

以上的就是所以thread的操作了，相对来说还比较简单。

启动线程

在构造函数中传入一个函数对象或者函数指针(后面简称线程函数)就直接启动线程了。如果函数需要其它参数，写在后面。

struct callable

{

       void operator()(void);

};

void func(int k);

callable c;

thread th1(c);         // 不能用thread th1(callable());

thread th2(&func, 12);

线程函数中的异常

线程中产生的任何异常处理的方式都是调用std::terminate( )直接退出，boost::thread_interrupted除外，它可以自己catch。

邻连和分离

thread对象销毁后线程可以继续执行。调用thread成员函数detach()使线程对象结束与线程执行体的关系。

中断

如果一个函数执行体不想被打断，在作用域声明一个this_thread::disable_interruption对象就可以了；如果需要临时打开中断，另一个比较有用this_thread::restore_interruption。

void g( )
{
// interruption enabled here
{
       boost::this_thread::disable_interruption di;
       // interruption disabled
     { 
              boost::this_thread::restore_interruption ri(di);
              // interruption now enabled
     } // ri destroyed, interruption disable again
} // di destroyed, interruption state restored
// interruption now enabled
}

线程标识ID

每个执行期的线程都有一个唯一的标识，可通过成员函数get_id()获得   , 或者在线程内部通过函数boost::this_thread::get_id()获得。

不同其它平台的编程，这个地方的ID似乎不是太重要，将线程与类关联后，对象在很多地方代替了ID的作用。

注意：class id是一个类，不是usigned int或short。

this_thread 命名空间

这个命名空间定义了很多函数与类，它们经常用于线程执行体中。因为线程体很难通过传参数、全局变量等常规方式得知执行它的线程对象，这个命名空间是程序员的唯一途径！

namespace this_thread

{

       thread::id get_id();

       void interruption_point();

       bool interruption_requested();

       bool interruption_enable();

       void sleep(TimeDuration const& rel_time);

       void yield();

       class disable_interruption;

       class restore_interruption;

}

模板函数at_thread_exit

template<typename Callable>

void at_thread_exit(Callable func);

线程结束时func被调用，很是有用。 ————？没找到方法

thread_group 类

class thread_group : private noncopyable
{
public:
       template<typename F>
       thread* create_thread(F threadfunc);
       void add_thread(thread* thrd);
       void remove_thread(thread* thrd);
       void join_all();
       void interrupt_all();
       int size() const;
};

thread_group提供一组线程对象的集合。create_thread比较方便，直接创建线程对象然后加到这个组里,new thread(threadfunc), size() + 1。