Boost.Thread is configured following the conventions used to build libraries
with separate source code. Boost.Thread will import/export the code
only if the user has specifically asked for it, by defining either BOOST_ALL_DYN_LINK
if they want all boost libraries to be dynamically linked, or BOOST_THREAD_DYN_LINK
if they want just this one to be dynamically liked.

The definition of these macros determines whether BOOST_THREAD_USE_DLL is defined.
If BOOST_THREAD_USE_DLL is not defined, the library will define BOOST_THREAD_USE_DLL
or BOOST_THREAD_USE_LIB depending on whether the platform. On non windows platforms
BOOST_THREAD_USE_LIB is defined if is not defined. In windows platforms, BOOST_THREAD_USE_LIB
is defined if BOOST_THREAD_USE_DLL and the compiler supports auto-tss cleanup
with Boost.Threads (for the time been Msvc and Intel)

The source code compiled when building the library defines a macros BOOST_THREAD_SOURCE
that is used to import or export it. The user must not define this macro in
any case.

Boost.Thread depends on some non header-only libraries.

Boost.System: This dependency is mandatory and you will need to link with
the library.

Boost.Chrono: This dependency is optional (see below how to configure)
and you will need to link with the library if you use some of the time
related interfaces.

Boost.DateTime: This dependency is mandatory, but even if Boost.DateTime
is a non header-only library Boost.Thread uses only parts that are header-only,
so in principle you should not need to link with the library.

It seems that there are some IDE (as e.g. Visual Studio) that deduce the libraries
that a program needs to link to inspecting the sources. Such IDE could force
to link to Boost.DateTime and/or Boost.Chrono.

As the single mandatory dependency is to Boost.System, the following

bjamtoolset=msvc-11.0--build-type=complete--with-thread

will install only boost_thread and boost_system.

Users of such IDE should force the Boost.Chrono and Boost.DateTime build using

Boost.Thread uses by default Boost.Chrono for the time related functions
and define BOOST_THREAD_USES_CHRONO
if BOOST_THREAD_DONT_USE_CHRONO
is not defined. The user should define BOOST_THREAD_DONT_USE_CHRONO
for compilers that don't work well with Boost.Chrono.

Boost.Thread uses by default an internal move semantic implementation.
Since version 3.0.0 you can use the move emulation emulation provided by
Boost.Move.

When BOOST_THREAD_VERSION==2 define
BOOST_THREAD_USES_MOVE
if you want to use Boost.Move interface. When BOOST_THREAD_VERSION>=3 define
BOOST_THREAD_DONT_USE_MOVE
if you don't want to use Boost.Move interface.

When BOOST_THREAD_VERSION<=3 define
BOOST_THREAD_DONT_USE_DATETIME if you don't want to use Boost.DateTime related interfaces. When
BOOST_THREAD_VERSION>3 define BOOST_THREAD_USES_DATETIME if you want to use Boost.DateTime related interfaces.

When BOOST_THREAD_VERSION>=4 define
BOOST_THREAD_PROVIDES_NESTED_LOCKS
if you want these features. When BOOST_THREAD_VERSION<4 define
BOOST_THREAD_DONT_PROVIDE_NESTED_LOCKS
if you don't want thes features.

Boost.Thread uses by default a thread::id on Posix based on the pthread
type (BOOST_THREAD_PROVIDES_BASIC_THREAD_ID). For backward compatibility
and also for compilers that don't work well with this modification the
user can define BOOST_THREAD_DONT_PROVIDE_BASIC_THREAD_ID.

Define BOOST_THREAD_DONT_PROVIDE_BASIC_THREAD_ID if you don't want these features.

The shared mutex implementation on Windows platform provides currently
less functionality than the generic one that is used for PTheads based
platforms. In order to have access to these functions, the user needs to
define BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
to use the generic implementation, that while could be less efficient,
provides all the functions.

When BOOST_THREAD_VERSION==2 define
BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN if you want these features. When BOOST_THREAD_VERSION>=3 define
BOOST_THREAD_DONT_PROVIDE_GENERIC_SHARED_MUTEX_ON_WIN if you don't want these features.

Boost.Threads includes in version 3 the Shared Locking Upwards Conversion
as defined in Shared
Locking. These conversions need to be used carefully to avoid deadlock
or livelock. The user need to define explicitly BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION
to get these upwards conversions.

When BOOST_THREAD_VERSION==2 define
BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION if you want these features. When BOOST_THREAD_VERSION>=3 define
BOOST_THREAD_DONT_PROVIDE_SHARED_MUTEX_UPWARDS_CONVERSION if you don't want these features.

In Shared
Locking the lock conversions are explicit. As this explicit conversion
breaks the lock interfaces, it is provided only if the BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION
is defined.

When BOOST_THREAD_VERSION==2 define
BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION if you want these features. When BOOST_THREAD_VERSION==3 define
BOOST_THREAD_DONT_PROVIDE_EXPLICIT_LOCK_CONVERSION if you don't want these features.

When BOOST_THREAD_VERSION==2 define
BOOST_THREAD_PROVIDES_FUTURE
if you want to use boost::future. When BOOST_THREAD_VERSION>=3 define
BOOST_THREAD_DONT_PROVIDE_FUTURE
if you want to use boost::unique_future.

C++11 promise initialize the associated state at construction time. Versions
of Boost.Thread previous to version 3.0.0 initialize it lazily at any point
in time in which this associated state is needed.

Since version 3.0.0 this difference in behavior can be configured. When
BOOST_THREAD_PROVIDES_PROMISE_LAZY
is defined the backward compatible behavior is provided.

When BOOST_THREAD_VERSION==2 define
BOOST_THREAD_DONT_PROVIDE_PROMISE_LAZY if you want to use boost::future. When BOOST_THREAD_VERSION>=3 define
BOOST_THREAD_PROVIDES_PROMISE_LAZY if you want to use boost::unique_future.

which introduces a dependency on Boost.Container. This feature is provided
only if BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS
is defined.

When BOOST_THREAD_VERSION==2 define
BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS if you want these features. When BOOST_THREAD_VERSION>=3 define
BOOST_THREAD_DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS if you don't want these features.

C++11 has a different semantic for the thread destructor and the move assignment.
Instead of detaching the thread, calls to terminate() if the thread was
joinable. When BOOST_THREAD_PROVIDES_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE
and BOOST_THREAD_PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE
is defined Boost.Thread provides the C++ semantic.

When BOOST_THREAD_VERSION==2 define
BOOST_THREAD_PROVIDES_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE if you want these features. When BOOST_THREAD_VERSION>=3 define
BOOST_THREAD_DONT_PROVIDE_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE if you don't want these features.

When BOOST_THREAD_VERSION==2 define
BOOST_THREAD_PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE if you want these features. When BOOST_THREAD_VERSION>=3 define
BOOST_THREAD_DONT_PROVIDE_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE if you don't want these features.

C++11 defines a default constructor for once_flag. When BOOST_THREAD_PROVIDES_ONCE_CXX11 is defined Boost.Thread provides this C++ semantics. In this case,
the previous aggregate syntax is not supported.

boost::once_flagonce=BOOST_ONCE_INIT;

You should now just do

boost::once_flagonce;

When BOOST_THREAD_VERSION==2 define
BOOST_THREAD_PROVIDES_ONCE_CXX11
if you want these features. When BOOST_THREAD_VERSION>=3 define
BOOST_THREAD_DONT_PROVIDE_ONCE_CXX11
if you don't want these features.

When BOOST_THREAD_VERSION<4 define
BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK
if you want this feature. When BOOST_THREAD_VERSION>=4 define
BOOST_THREAD_DONT_PROVIDE_SIGNATURE_PACKAGED_TASK
if you don't want this feature.

C++11 future<>::get() invalidates the future once its value has been
obtained. When BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET is defined Boost.Thread provides this C++ feature.

Warning

This is a breaking change respect to version 3.x.

When BOOST_THREAD_VERSION<4 define
BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
if you want this feature. When BOOST_THREAD_VERSION>=4 define
BOOST_THREAD_DONT_PROVIDE_FUTURE_INVALID_AFTER_GET
if you don't want this feature.

Boost.Thread defines BOOST_THREAD_PROVIDES_INTERRUPTIONS if neither BOOST_THREAD_PROVIDES_INTERRUPTIONS
nor BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS are defined, so that there
is no compatibility break.