Boost C++ 库

默认情况下，Boost.Thread 使用 Boost.Chrono 进行与时间相关的函数，如果未定义 BOOST_THREAD_DONT_USE_CHRONO，则定义 BOOST_THREAD_USES_CHRONO。 对于与 Boost.Chrono 配合不佳的编译器，用户应定义 BOOST_THREAD_DONT_USE_CHRONO。

	警告
	当定义 BOOST_THREAD_PLATFORM_WIN32 时，无论用户设置如何，都会定义 BOOST_THREAD_USES_CHRONO。

默认情况下，Boost.Thread 使用内部移动语义实现。 从 3.0.0 版本开始，您可以使用 Boost.Move 提供的移动仿真。

当 BOOST_THREAD_VERSION==2 时，如果您想使用 Boost.Move 接口，请定义 BOOST_THREAD_USES_MOVE 。 当 BOOST_THREAD_VERSION>=3 时，如果您不想使用 Boost.Move 接口，请定义 BOOST_THREAD_DONT_USE_MOVE 。

Boost 1.35.0 中引入的与时间相关的 Boost.DateTime 函数（使用Boost.Date_Time 库）已弃用。 这些包括（但不限于）

当 BOOST_THREAD_VERSION<=3 && 定义了 BOOST_THREAD_PLATFORM_PTHREAD 时，如果您不想使用与 Boost.DateTime 相关的接口，请定义 BOOST_THREAD_DONT_USE_DATETIME。 当 BOOST_THREAD_VERSION>3 && 定义了 BOOST_THREAD_PLATFORM_PTHREAD 时，如果您想使用与 Boost.DateTime 相关的接口，请定义 BOOST_THREAD_USES_DATETIME。

	警告
	当定义 BOOST_THREAD_PLATFORM_WIN32 时，无论用户设置如何，都会定义 BOOST_THREAD_USES_DATETIME。

默认情况下，Boost.Thread 在 POSIX 平台上使用 Boost.Atomic 来实现 call_once。

如果您想使用 Boost.Atomic，请定义 BOOST_THREAD_USES_ATOMIC 。 如果您不想使用 Boost.Atomic 或您的平台不支持它，请定义 BOOST_THREAD_DONT_USE_ATOMIC 。

以下运算符已弃用

当定义 BOOST_THREAD_PROVIDES_THREAD_EQ 时，Boost.Thread 提供这些已弃用的功能。

请改用

	警告
	这是相对于 1.x 版本的重大更改。

当 BOOST_THREAD_VERSION>=4 时，如果您想要此功能，请定义 BOOST_THREAD_PROVIDES_THREAD_EQ 。 当 BOOST_THREAD_VERSION<4 时，如果您不想要此功能，请定义 BOOST_THREAD_DONT_PROVIDE_THREAD_EQ 。

boost::condition 已弃用。 当定义 BOOST_THREAD_PROVIDES_CONDITION 时，Boost.Thread 提供此已弃用的功能。

请改用 boost::condition_variable_any。

	警告
	这是相对于 1.x 版本的重大更改。

当 BOOST_THREAD_VERSION>3 时，如果您想要此功能，请定义 BOOST_THREAD_PROVIDES_CONDITION。 当 BOOST_THREAD_VERSION<=3 时，如果您不想要此功能，请定义 BOOST_THREAD_DONT_PROVIDE_CONDITION。

以下嵌套 typedef 已弃用

当定义 BOOST_THREAD_PROVIDES_NESTED_LOCKS 时，Boost.Thread 提供这些已弃用的功能。

请改用 * boost::unique_lock<boost::mutex>, * boost::unique_lock<boost::mutex> 与 try_to_lock_t 构造函数, * boost::unique_lock<boost::timed_mutex> * boost::unique_lock<boost::timed_mutex> 与 try_to_lock_t 构造函数 * boost::unique_lock<boost::timed_mutex> * boost::unique_lock<boost::recursive_mutex>, * boost::unique_lock<boost::recursive_mutex> 与 try_to_lock_t 构造函数, * boost::unique_lock<boost::recursive_timed_mutex> * boost::unique_lock<boost::recursive_timed_mutex> 与 try_to_lock_t 构造函数 * boost::unique_lock<boost::recursive_timed_mutex>

	警告
	这是相对于 1.x 版本的重大更改。

当 BOOST_THREAD_VERSION>=4 时，如果您想要这些功能，请定义 BOOST_THREAD_PROVIDES_NESTED_LOCKS。 当 BOOST_THREAD_VERSION<4 时，如果您不想要这些功能，请定义 BOOST_THREAD_DONT_PROVIDE_NESTED_LOCKS。

默认情况下，Boost.Thread 在基于 Posix 的系统上使用基于 pthread 类型的 thread::id (BOOST_THREAD_PROVIDES_BASIC_THREAD_ID)。 为了向后兼容以及为了与此修改配合不佳的编译器，用户可以定义 BOOST_THREAD_DONT_PROVIDE_BASIC_THREAD_ID。

如果您不想要这些功能，请定义 BOOST_THREAD_DONT_PROVIDE_BASIC_THREAD_ID 。

Windows 平台上的共享互斥锁实现目前提供的功能比用于基于 PTheads 的平台的通用实现少。 为了访问这些功能，用户需要定义 BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN 以使用通用实现，虽然效率可能较低，但提供了所有功能。

当 BOOST_THREAD_VERSION==2 时，如果您想要这些功能，请定义 BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN 。 当 BOOST_THREAD_VERSION>=3 时，如果您不想要这些功能，请定义 BOOST_THREAD_DONT_PROVIDE_GENERIC_SHARED_MUTEX_ON_WIN 。

Boost.Threads 版本 3 包含 共享锁定中定义的共享锁定向上转换。 需要谨慎使用这些转换以避免死锁或活锁。 用户需要显式定义 BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS 才能获得这些向上转换。

当 BOOST_THREAD_VERSION==2 时，如果您想要这些功能，请定义 BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS 。 当 BOOST_THREAD_VERSION>=3 时，如果您不想要这些功能，请定义 BOOST_THREAD_DONT_PROVIDE_SHARED_MUTEX_UPWARDS_CONVERSION 。

在 共享锁定中，锁转换是显式的。 由于此显式转换破坏了锁接口，因此仅当定义了 BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION 时才提供。

当 BOOST_THREAD_VERSION==2 时，如果您想要这些功能，请定义 BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION 。 当 BOOST_THREAD_VERSION==3 时，如果您不想要这些功能，请定义 BOOST_THREAD_DONT_PROVIDE_EXPLICIT_LOCK_CONVERSION 。

C++11 使用 std::future。 3.0.0 之前的 Boost.Thread 版本使用 boost:unique_future。 从 3.0.0 版本开始，当定义 BOOST_THREAD_PROVIDES_FUTURE 时，boost::future 替换 boost::unique_future。 然而，文档不再包含 boost::unique_future。

当 BOOST_THREAD_VERSION==2 时，如果您想使用 boost::future，请定义 BOOST_THREAD_PROVIDES_FUTURE。 当 BOOST_THREAD_VERSION>=3 时，如果您想使用 boost::unique_future，请定义 BOOST_THREAD_DONT_PROVIDE_FUTURE。

C++11 promise 在构造时初始化关联状态。 3.0.0 之前的 Boost.Thread 版本在需要此关联状态的任何时间点延迟初始化它。

从 3.0.0 版本开始，可以配置此行为差异。 当定义 BOOST_THREAD_PROVIDES_PROMISE_LAZY 时，提供向后兼容的行为。

当 BOOST_THREAD_VERSION==2 时，如果您想使用 boost::future，请定义 BOOST_THREAD_DONT_PROVIDE_PROMISE_LAZY 。 当 BOOST_THREAD_VERSION>=3 时，如果您想使用 boost::unique_future，请定义 BOOST_THREAD_PROVIDES_PROMISE_LAZY 。

C++11 std::promise 提供带有分配器的构造函数。

template <typename R>
class promise
{
  public:
    template <class Allocator>
    explicit promise(allocator_arg_t, Allocator a);
  // ...
};
template <class R, class Alloc> struct uses_allocator<promise<R>,Alloc>: true_type {};

其中

struct allocator_arg_t { };
constexpr allocator_arg_t allocator_arg = allocator_arg_t();

template <class T, class Alloc> struct uses_allocator;

从 3.0.0 版本开始，Boost.Thread 使用以下接口实现此构造函数

namespace boost
{
  typedef container::allocator_arg_t allocator_arg_t;
  constexpr allocator_arg_t allocator_arg = {};

  namespace container
  {
    template <class R, class Alloc>
    struct uses_allocator<promise<R>,Alloc>: true_type {};
  }
  template <class T, class Alloc>
  struct uses_allocator : public container::uses_allocator<T, Alloc> {};
}

这引入了对 Boost.Container 的依赖。 仅当定义了 BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS 时才提供此功能。

当 BOOST_THREAD_VERSION==2 时，如果您想要这些功能，请定义 BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS 。 当 BOOST_THREAD_VERSION>=3 时，如果您不想要这些功能，请定义 BOOST_THREAD_DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS 。

C++11 对于线程析构函数和移动赋值具有不同的语义。 如果线程可连接，则调用 terminate() 而不是分离线程。 当定义 BOOST_THREAD_PROVIDES_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE 和 BOOST_THREAD_PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE 时，Boost.Thread 提供 C++ 语义。

当 BOOST_THREAD_VERSION==2 时，如果您想要这些功能，请定义 BOOST_THREAD_PROVIDES_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE 。 当 BOOST_THREAD_VERSION>=3 时，如果您不想要这些功能，请定义 BOOST_THREAD_DONT_PROVIDE_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE 。

当 BOOST_THREAD_VERSION==2 时，如果您想要这些功能，请定义 BOOST_THREAD_PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE 。 当 BOOST_THREAD_VERSION>=3 时，如果您不想要这些功能，请定义 BOOST_THREAD_DONT_PROVIDE_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE 。

C++11 为 once_flag 定义了一个默认构造函数。 当定义 BOOST_THREAD_PROVIDES_ONCE_CXX11 时，Boost.Thread 提供此 C++ 语义。 在这种情况下，不支持以前的聚合语法。

boost::once_flag once = BOOST_ONCE_INIT;

您现在应该只执行

boost::once_flag once;

当 BOOST_THREAD_VERSION==2 时，如果您想要这些功能，请定义 BOOST_THREAD_PROVIDES_ONCE_CXX11。 当 BOOST_THREAD_VERSION>=3 时，如果您不想要这些功能，请定义 BOOST_THREAD_DONT_PROVIDE_ONCE_CXX11。

C++11 packaged task 类具有 Signature 模板参数。 当定义 BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK 时，Boost.Thread 提供此 C++ 功能。

	警告
	这是相对于 3.x 版本的重大更改。

当 BOOST_THREAD_VERSION<4 时，如果您想要此功能，请定义 BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK。 当 BOOST_THREAD_VERSION>=4 时，如果您不想要此功能，请定义 BOOST_THREAD_DONT_PROVIDE_SIGNATURE_PACKAGED_TASK。

C++11 线程构造函数接受可变数量的右值参数。 当定义 BOOST_THREAD_PROVIDES_VARIADIC_THREAD 时，如果未定义以下内容，则 Boost.Thread 提供此 C++ 功能

当 BOOST_THREAD_VERSION>4 时，如果您不想要此功能，请定义 BOOST_THREAD_DONT_PROVIDE_VARIADIC_THREAD 。

C++11 future<>::get() 在获取其值后使 future 无效。 当定义 BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET 时，Boost.Thread 提供此 C++ 功能。

	警告
	这是相对于 3.x 版本的重大更改。

当 BOOST_THREAD_VERSION<4 时，如果您想要此功能，请定义 BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET。 当 BOOST_THREAD_VERSION>=4 时，如果您不想要此功能，请定义 BOOST_THREAD_DONT_PROVIDE_FUTURE_INVALID_AFTER_GET。

线程中断虽然有用，但会使任何中断点效率低于线程不可中断的情况。

当定义 BOOST_THREAD_PROVIDES_INTERRUPTIONS 时，Boost.Thread 提供中断。 当定义 BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS 时，Boost.Thread 不提供中断。

Boost.Thread 定义 BOOST_THREAD_PROVIDES_INTERRUPTIONS，如果既未定义 BOOST_THREAD_PROVIDES_INTERRUPTIONS 也未定义 BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS，以便不存在兼容性中断。

BOOST_THREAD_VERSION 定义 Boost.Thread 版本。 默认版本为 2。在这种情况下，如果未请求相反的情况，则定义以下中断或扩展宏

用户可以通过将 BOOST_THREAD_VERSION 定义为 3 来请求版本 3。 在这种情况下，如果未请求相反的情况，则定义以下中断或扩展宏

用户可以通过将 BOOST_THREAD_VERSION 定义为 4 来请求版本 4。 在这种情况下，如果未请求相反的情况，则定义以下中断或扩展宏

如果 __SUNPRO_CC < 0x5100，则库定义

如果 __SUNPRO_CC < 0x5100，则库定义

如果 __IBMCPP__ < 1100，则库定义

并且 Boost.Thread 不与 Boost.Chrono 链接。

如果 _WIN32_WCE && _WIN32_WCE==0x501，则库定义