概要

#include <boost/thread/thread.hpp>
namespace boost
{
  class thread;
  void swap(thread& lhs,thread& rhs) noexcept;

  namespace this_thread
  {
    thread::id get_id() noexcept;
    template<typename TimeDuration>
    void yield() noexcept;
    template <class Clock, class Duration>
    void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
    template <class Rep, class Period>
    void sleep_for(const chrono::duration<Rep, Period>& rel_time);
    namespace no_interruption_point  // EXTENSION
    {
        template <class Clock, class Duration>
        void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
        template <class Rep, class Period>
        void sleep_for(const chrono::duration<Rep, Period>& rel_time);
    }
    template<typename Callable>
    void at_thread_exit(Callable func); // EXTENSION

    void interruption_point(); // EXTENSION
    bool interruption_requested() noexcept; // EXTENSION
    bool interruption_enabled() noexcept; // EXTENSION 
    class disable_interruption; // EXTENSION
    class restore_interruption; // EXTENSION

  #if defined BOOST_THREAD_USES_DATETIME
    template <TimeDuration>
    void sleep(TimeDuration const& rel_time);  // DEPRECATED
    void sleep(system_time const& abs_time); // DEPRECATED
  #endif
  }
  class thread_group; // EXTENSION

}

目录

1 启动线程 Launching threads
2 线程属性 Thread attributes
3 线程函数异常 Exceptions in thread functions
4 分离线程 Detaching thread
5 等待线程 Joining a thread
6 析构函数 Destructor V1-2
7 析构函数 Destructor V3-X
8 中断 Interruption
9 线程 IDs Thread IDs
10 Using native interfaces with Boost.Thread resources
11 Using Boost.Thread interfaces in a native thread

boost::thread 类负责启动和管理线程。一个 boost.thread 对象代表一个独立线程的执行、或不代表任何线程、并且一个 boost.thread 对象最多表示一个正在执行的线程：也即 boost.thread 是不可复制的。

然而 boost.thread 类型的对象是可移动的，因此该对象能够存储在一个可移动的容器中，并可作为函数的返回值。线程创建的细节被封装于此函数。

boost::thread make_thread();

void f()
{
    boost::thread some_thread=make_thread();
    some_thread.join();
}

1 线程启动

通过传递一个一个 callable 类型的对象给新线程即可启动一个不带任何参数的线程。随后此对象被拷贝到线程内部存储，并被新线程调用执行。如果此对象不能（或不允许）被复制，则 boost::ref 可以用于来传递此可调用对象的引用，在这种情况下，需要注意确保被引用的可执行对象的生命周期长于线程对象。

struct callable
{
    void operator()();
};

boost::thread copies_are_safe()
{
    callable x;
    return boost::thread(x);
} // x is destroyed, but the newly-created thread has a copy, so this is OK

boost::thread oops()
{
    callable x;
    return boost::thread(boost::ref(x));
} // x is destroyed, but the newly-created thread still has a reference
  // this leads to undefined behaviour

如果你需要创建一个线程执行带参数的 fucntion 或 callable object，可以通过 boost::thread 构造函数来传递参数。

void find_the_question(int the_answer);

boost::thread deep_thought_2(find_the_question,42);

这里的参数是拷贝到线程对象内部，如果需要传递引用，同样使用 boost::ref。对于传递参数的个数没有限制。

2 线程属性

线程启动时需要指定具体的线程属性，如栈大小、调度、优先级等，或者某些平台的特殊属性。至于如何提供用于不同特定平台的可移植通用接口。boost.thread 通过 thread::attributes 提供了一个通用的中间方式，至少对于栈大小设置具有可移植性。如下：

boost::thread::attributes attrs;
attrs.set_stack_size(4096*10);
boost::thread deep_thought_2(attrs, find_the_question, 42);

即使这个简单的属性在某些平台也会出现兼容性问题，例如某些平台要求栈大小应该有一个最小大小或者是页大小的整数倍。boost 线程库能够适应不同平台的栈大小的限制，使得用户不需要关心。

这里提供了一个单个属性设置的可移植方法。但是为了在 Thread 构造时设置其它属性，需要使用不可移植代码。

在 PThread 平台，用户需要获取线程属性句柄，并用于所有属性。

下面例释了在 PThread 平台上如何设置栈大小和调度策略：

boost::thread::attributes attrs;
// set portable attributes
// ...
attr.set_stack_size(4096*10);
#if defined(BOOST_THREAD_PLATFORM_WIN32)
    // ... window version
#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
    // ... pthread version
    pthread_attr_setschedpolicy(attr.native_handle(), SCHED_RR);
#else
#error "Boost threads unavailable on this platform"
#endif
boost::thread th(attrs, find_the_question, 42);

在 Windows 平台则不能如此简单，下面时 windows 上设置其特有属性 LPSECURITY_ATTRIBUTES。如：

#if defined(BOOST_THREAD_PLATFORM_WIN32)
  boost::thread::attributes attrs;
  // set portable attributes
  attr.set_stack_size(4096*10);
  // set non portable attribute
  LPSECURITY_ATTRIBUTES sec;
  // init sec 
  attr.set_security(sec);
  boost::thread th(attrs, find_the_question, 42);
  // Set other thread attributes using the native_handle_type.
  //...
#else
#error "Platform not supported"
#endif

3 Thread 函数异常

当调用 boost::thread 构造函数产生一个异常时，将调用 std::terminate() 而不是 boost::thread_interrupted 类型的一个中断。

4 Thread 分离

通过调用 detach() 函数，线程可以明确与父线程分离开来。在这种情况下，boost::thread 对象停止代表新产生的线程，而不代表任何线程。

int main()
{
  boost::thread t(my_func);
  t.detach();
}

5 Joining 线程

为了等待一个线程执行完成，boost::thread 的成员函数 join()，__join_for() 或者 __join_until() （timed_join() 过时的）必须被调用。join() 将阻塞调用线程直到 boost::thread 所代表的新线程执行完成。

int main()
{
  boost::thread t(my_func);
  t.join();
}

如果 boost::thread 对象所代表的线程已经执行完成，或者 boost::thread 对象不是一个线程，那么调用 join() 将立即返回。

int main()
{
  boost::thread t;
  t.join(); // do nothing
}

定时等待是类似的，除了 __join_for() 或 __join_until() 的返回条件是线程执行完成或者超时。

int main()
{
  boost::thread t;
  if ( t.join_for(boost::chrono::milliseconds(500)) )
    // do something else
  t.join(); // join anyway
}

5 Destructor V1-2

当一个 boost::thread 对象代表一个线程的执行被销毁时，如果此线程是 joinable，则此线程执行的程序将终止。

int main()
{
  boost::thread t(my_func);
} // calls std::terminate()

你可以使用 thread_joiner 用于确保新线程在构造函数中等待。

int main()
{
  boost::thread t(my_func);
  boost::thread_joiner g(t);
  // do something else
} // here the thread_joiner destructor will join the thread before it is destroyed.

6 线程中断

通过调用 boost::thread 的 interrupt() 成员函数可以终止一个正在执行的线程。调用后，线程继续执行到任意一个特定的中断点（或者正在执行的线程正在阻塞中），且开启了中断使能；那么一个 boost::thread_interrupted 异常将从被终止的线程抛出。除非此中断发生于线程的主函数，否则栈将按照执行时候自动存储的对象调用其析构函数。与其它异常相区别，当 boost::thread_interrupted 产生于 thread-main 函数的外部时，中断的调用将不会引起 std::terminate 的调用，故导致主函数好像正常返回的假象。

如果一个线程希望避免被中断，可以创建一个 boost::this_thread::disable_interruption 实例，中断使不能对象在构造函数中调用，在对应的实例被析构后恢复使能。

void f()
{
    // interruption enabled here
    {
        boost::this_thread::disable_interruption di;
        // interruption disabled
        {
            boost::this_thread::disable_interruption di2;
            // interruption still disabled
        } // di2 destroyed, interruption state restored
        // interruption still disabled
    } // di destroyed, interruption state restored
    // interruption now enabled
}

boost::this_thread::disable_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
}

在任何位置，均可以通过调用 boost::this_thread::interruption_enabled() 获取当前的中断使能状态。

Predefined Interruption Points
以下函数均为 “中断点”，如果线程时中断使能的，在此线程接收到中断请求时，中断点就会抛出 boost::thread_interrupted 异常。

• boost::thread::join()
• boost::thread::timed_join()
• boost::thread::try_join_for(),
• boost::thread::try_join_until(),
• boost::condition_variable::wait()
• boost::condition_variable::timed_wait()
• boost::condition_variable::wait_for()
• boost::condition_variable::wait_until()
• boost::condition_variable_any::wait()
• boost::condition_variable_any::timed_wait()
• boost::condition_variable_any::wait_for()
• boost::condition_variable_any::wait_until()
• boost::thread::sleep()
• boost::this_thread::sleep_for()
• boost::this_thread::sleep_until()
• boost::this_thread::interruption_point()

7 线程 ID

boost::thread::id 的对象能够用来标识线程，每个正在运行的线程都可以获取一个唯一可用的线程id，可以通过调用 boost::thread 的成员函数 get_id()，或者通过在线程中调用 boost:this_thread::get_id()。boost::thread::id 可以被复制， 可以被用作与之关联容器的标识。线程 id 提供了各种比较操作符，线程id 也可以通过输出流的输出操作符输出（虽然其输出格式没有规定）。

一个 boost::thread::id 要么指向一个线程，要么不知想任何线程。注意所有 Not-a-Thread 的线程 id 都是相等的。

8 Boost.Thread 使用原始线程接口

boost::thread 类有一个成员函数 native_handle_type() 和 native_handle() 用来获取原始线程句柄。原始句柄可以用来改变线程调度策略。

一般来说，通过 原始句柄来操作 boost.thread 对象是不安全的。例如下面示例代码中，使用原始接口分离了线程，但是 boost::thread 对象仍然处于可等待状态，调用 boost::joinable() 函数仍然返回 true，而原始线程已经不可等待。

thread t(fct);
thread::native_handle_type hnd=t.native_handle();
pthread_detach(hnd);
assert(t.joinable());

9 在原始线程中使用 Boost.Thread 接口

在本文中，一个原始接口创建的线程被称作一个原始线程。在原始线程中可以使用同步相关的 boost::this_thread 类下的 yield、sleep、sleep_for、sleep_until 等函数。

int main() {
  // ... 
  boost::this_thread::sleep_for(boost::chrono::milliseconds(10));
  // ... 
}

然而在原始线程中 boost::this_thread 中断相关的接口就失效了。例如：由于使用 boost::this_thread::disable_interruption 和 boost::this_thread::restore_interruption 将没有任何作用，且调用 boost::this_thread::interruption_point()
也被忽略，故 boost::this_thread::interruption_enabled() 将返回 false。