Boost C++ 库

通过将一个可调用类型的对象（可以使用无参数调用）传递给构造函数来启动新线程。 然后将该对象复制到内部存储，并在新创建的执行线程上调用。 如果该对象不得（或不能）被复制，则可以使用 boost::ref 传入对函数对象的引用。 在这种情况下，Boost.Thread 的用户必须确保被引用的对象比新创建的执行线程寿命更长。

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

如果您希望使用需要提供参数的函数或可调用对象构造 boost::thread 的实例，则可以通过将其他参数传递给 boost::thread 构造函数来完成

void find_the_question(int the_answer);

boost::thread deep_thought_2(find_the_question,42);

参数被复制到内部线程结构中：如果需要引用，请使用 boost::ref，就像对可调用函数的引用一样。

可以传递的附加参数的数量没有明确的限制。

以这种方式启动的线程是使用实现定义的线程属性（如堆栈大小、调度、优先级等）或任何平台特定属性创建的。 如何提供允许用户设置平台特定属性的可移植接口尚不清楚。 Boost.Thread 采取折衷方案，通过类 thread::attributes 允许至少以可移植的方式设置堆栈大小，如下所示

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

即使对于这个简单的属性，也可能存在可移植性问题，因为某些平台可能要求堆栈大小应具有最小大小和/或是给定页面大小的倍数。 该库会根据平台约束调整请求的大小，以便用户无需担心。

这是以可移植方式提供的唯一属性。 为了在构造时设置任何其他线程属性，用户需要使用不可移植的代码。

在 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 上线程创建相关的类型，它通过 thread::attributes 类进行模拟。 这是 LPSECURITY_ATTRIBUTES lpThreadAttributes。 Boost.Thread 提供了一个不可移植的 set_security 函数，以便用户可以在线程创建之前提供它，如下所示

#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

如果传递给 boost::thread 构造函数的函数或可调用对象在调用时传播了异常，但该异常不是 boost::thread_interrupted 类型，则会调用 std::terminate()。

可以通过显式调用 detach() 成员函数在 boost::thread 对象上分离线程。 在这种情况下，boost::thread 对象不再代表现在分离的线程，而是代表 非线程。

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

为了等待执行线程完成，必须使用 join()、__join_for 或 __join_until（timed_join() 已弃用）boost::thread 对象的成员函数。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
}

当代表执行线程的 boost::thread 对象被销毁时，线程将变为 分离状态。 一旦线程被分离，它将继续执行，直到构造时提供的函数或可调用对象的调用完成，或者程序终止。 线程也可以通过显式调用 detach() 成员函数在 boost::thread 对象上分离。 在这种情况下，boost::thread 对象不再代表现在分离的线程，而是代表 非线程。

当代表执行线程的 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.

可以通过调用相应 boost::thread 对象的 interrupt() 成员函数来中断正在运行的线程。 当中断线程接下来执行指定的中断点之一（或者如果它当前在执行其中一个时被 阻塞），并且启用了中断，则将在中断线程中抛出 boost::thread_interrupted 异常。 除非在中断线程的线程主函数内部捕获此异常，否则堆栈展开过程（与任何其他异常一样）会导致执行具有自动存储持续时间的析构函数。 与其他异常不同，当 boost::thread_interrupted 从线程主函数中传播出来时，这不会导致调用 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 实例的效果可以通过构造 boost::this_thread::restore_interruption 的实例来暂时反转，传入有问题的 boost::this_thread::disable_interruption 对象。 这会将中断状态恢复为构造 boost::this_thread::disable_interruption 对象时的状态，然后在销毁 boost::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
}

在任何时候，都可以通过调用 boost::this_thread::interruption_enabled() 来查询当前线程的中断状态。

预定义的中断点

以下函数是中断点，如果为当前线程启用中断，并且为当前线程请求中断，则它们将抛出 boost::thread_interrupted

boost::thread::id 类的对象可用于标识线程。 每个正在运行的执行线程都有一个唯一的 ID，可以从相应的 boost::thread 通过调用 get_id() 成员函数获得，或者通过从线程内部调用 boost::this_thread::get_id() 获得。boost::thread::id 类的对象可以复制，并用作关联容器中的键：提供了全范围的比较运算符。 线程 ID 也可以使用流插入运算符写入输出流，但输出格式未指定。

boost::thread::id 的每个实例要么引用某个线程，要么引用 非线程。 引用 非线程 的实例彼此比较相等，但不等于引用实际执行线程的任何实例。 boost::thread::id 上的比较运算符为每个不相等的线程 ID 产生一个全序。

boost::thread 类具有成员 native_handle_type 和 native_handle，提供对底层原生句柄的访问。

此原生句柄可用于更改例如调度。

通常，将此句柄与可能与 Boost.Thread 提供的操作冲突的操作一起使用是不安全的。 一个错误用法的示例可能是直接分离线程，因为它不会更改 boost::thread 实例的内部结构，因此例如 joinable 函数将继续返回 true，而原生线程不再可加入。

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

使用原生接口创建的任何执行线程在本文档中都称为原生线程。

原生执行线程的第一个示例是主线程。

用户可以使用 boost::this_thread yield、sleep、sleep_for、sleep_until 函数访问与原生当前线程相关的一些同步函数。

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

当然，Boost.Thread 提供的所有同步工具也可在原生线程上使用。

当从使用原生接口创建的线程调用时，boost::this_thread 中断相关函数以降级模式运行，即 boost::this_thread::interruption_enabled() 返回 false。 因此，使用 boost::this_thread::disable_interruption 和 boost::this_thread::restore_interruption 将不起作用，并且对 boost::this_thread::interruption_point() 的调用将被忽略。

由于中断线程的唯一方法是通过 boost::thread 实例，因此 interruption_request() 对于原生线程将返回 false。

pthread_exit POSIX 限制

glibc/NPTL 中的 pthread_exit 会导致“强制展开”，这几乎类似于 C++ 异常，但又不完全是。 例如，在 Mac OS X 上，pthread_exit 会在不调用 C++ 析构函数的情况下展开。

此行为与当前的 Boost.Thread 设计不兼容，因此在 POSIX 线程中使用此函数会导致任何 Boost.Thread 函数的未定义行为。

thread() noexcept;

thread(thread&& other) noexcept;

thread& operator=(thread&& other) noexcept;

template<typename Callable>
thread(Callable func);

template<typename Callable>
thread(attributes& attrs, Callable func);

template<typename Callable>
thread(Callable &&func);

template<typename Callable>
thread(attributes& attrs, Callable func);

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

~thread();

bool joinable() const noexcept;

void join();

bool timed_join(const system_time& wait_until);

template<typename TimeDuration>
bool timed_join(TimeDuration const& rel_time);

	警告
	自 3.00 版本起已弃用。 请改用 try_join_for、try_join_until。

template <class Rep, class Period>
bool try_join_for(const chrono::duration<Rep, Period>& rel_time);

template <class Clock, class Duration>
bool try_join_until(const chrono::time_point<Clock, Duration>& abs_time);

void detach();

thread::id get_id() const noexcept;

void interrupt();

unsigned hardware_concurrency() noexcept;

unsigned physical_concurrency() noexcept;

typedef platform-specific-type native_handle_type;
native_handle_type native_handle();

bool operator==(const thread& other) const;

	警告
	自 4.0.0 版本起已弃用。 请改用 a.get_id()==b.get_id() 代替。

bool operator!=(const thread& other) const;

	警告
	自 4.0.0 版本起已弃用。 请改用 a.get_id()!=b.get_id() 代替。

void sleep(system_time const& abs_time);

	警告
	自 3.0.0 版本起已弃用。 请改用 this_thread::sleep_for() 或 this_thread::sleep_until()。

void yield();

	警告
	自 3.0.0 版本起已弃用。 请改用 this_thread::yield()。

void swap(thread& other) noexcept;

#include <boost/thread/thread.hpp>

void swap(thread& lhs,thread& rhs) noexcept;

#include <boost/thread/thread.hpp>

class thread::id
{
public:
    id() noexcept;

    bool operator==(const id& y) const noexcept;
    bool operator!=(const id& y) const noexcept;
    bool operator<(const id& y) const noexcept;
    bool operator>(const id& y) const noexcept;
    bool operator<=(const id& y) const noexcept;
    bool operator>=(const id& y) const noexcept;

    template<class charT, class traits>
    friend std::basic_ostream<charT, traits>&
    operator<<(std::basic_ostream<charT, traits>& os, const id& x);
};

id() noexcept;

bool operator==(const id& y) const noexcept;

bool operator!=(const id& y) const noexcept;

bool operator<(const id& y) const noexcept;

bool operator>(const id& y) const noexcept;

bool operator<=(const id& y) const noexcept;

bool operator>=(const id& y) const noexcept;

template<class charT, class traits>
friend std::basic_ostream<charT, traits>&
operator<<(std::basic_ostream<charT, traits>& os, const id& x);

class thread::attributes {
public:
    attributes() noexcept;
    ~ attributes()=default;
    // stack
    void set_stack_size(std::size_t size) noexcept;
    std::size_t get_stack_size() const noexcept;

#if defined BOOST_THREAD_DEFINES_THREAD_ATTRIBUTES_NATIVE_HANDLE
    typedef platform-specific-type native_handle_type;
    native_handle_type* native_handle() noexcept;
    const native_handle_type* native_handle() const noexcept;
#endif

};

thread_attributes() noexcept;

void set_stack_size(std::size_t size) noexcept;

std::size_t get_stack_size() const noexcept;

typedef platform-specific-type native_handle_type;
    typedef platform-specific-type native_handle_type;
    native_handle_type* native_handle() noexcept;
    const native_handle_type* native_handle() const noexcept;

#include <boost/thread/thread.hpp>

namespace this_thread
{
    thread::id get_id() noexcept;
}

#include <boost/thread/thread.hpp>

namespace this_thread
{
    void interruption_point();
}

#include <boost/thread/thread.hpp>

namespace this_thread
{
    bool interruption_requested() noexcept;
}

#include <boost/thread/thread.hpp>

namespace this_thread
{
    bool interruption_enabled() noexcept;
}

#include <boost/thread/thread.hpp>

namespace this_thread
{
    template<typename TimeDuration>
    void sleep(TimeDuration const& rel_time);
    void sleep(system_time const& abs_time)
}

	警告
	自 3.0.0 版本起已弃用。 请改用 sleep_for() 和 sleep_until()。

#include <boost/thread/thread.hpp>

namespace this_thread
{
  template <class Clock, class Duration>
  void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
  namespace no_interruption_point
  {
    template <class Clock, class Duration>
    void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
  }
}

#include <boost/thread/thread.hpp>

namespace this_thread
{
  template <class Rep, class Period>
  void sleep_for(const chrono::duration<Rep, Period>& rel_time);
  namespace no_interruption_point
  {
    template <class Rep, class Period>
    void sleep_for(const chrono::duration<Rep, Period>& rel_time);
  }
}

#include <boost/thread/thread.hpp>

namespace this_thread
{
    void yield() noexcept;
}

#include <boost/thread/thread.hpp>

namespace this_thread
{
    class disable_interruption
    {
    public:
        disable_interruption(const disable_interruption&) = delete;
        disable_interruption& operator=(const disable_interruption&) = delete;
        disable_interruption() noexcept;
        ~disable_interruption() noexcept;
    };
}

boost::this_thread::disable_interruption 在构造时禁用当前线程的中断，并在析构时恢复先前的中断状态。disable_interruption 的实例无法复制或移动。

disable_interruption() noexcept;

~disable_interruption() noexcept;

#include <boost/thread/thread.hpp>

namespace this_thread
{
    class restore_interruption
    {
    public:
        restore_interruption(const restore_interruption&) = delete;
        restore_interruption& operator=(const restore_interruption&) = delete;
        explicit restore_interruption(disable_interruption& disabler) noexcept;
        ~restore_interruption() noexcept;
    };
}

在构造 boost::this_thread::restore_interruption 的实例时，当前线程的中断状态将恢复为提供的 disable_interruption 实例的构造函数存储的中断状态。当该实例被销毁时，中断将再次被禁用。restore_interruption 的实例无法复制或移动。

explicit restore_interruption(disable_interruption& disabler) noexcept;

~restore_interruption() noexcept;

#include <boost/thread/thread.hpp>

template<typename Callable>
void at_thread_exit(Callable func);

thread_group();

~thread_group();

template<typename F>
thread* create_thread(F threadfunc);

void add_thread(thread* thrd);

void remove_thread(thread* thrd);

void join_all();

bool is_this_thread_in();

bool is_thread_in(thread* thrd);

void interrupt_all();

int size();