These deprecated features will be provided by default up to boost 1.52. If
you don't want to include the deprecated features you could define BOOST_THREAD_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V3_0_0.
Since 1.53 these features will not be included any more by default. Since this
version, if you want to include the deprecated features yet you could define
BOOST_THREAD_PROVIDE_DEPRECATED_FEATURES_SINCE_V3_0_0. These deprecated features
will be only available until boost 1.55, that is you have 1 year and a half
to move to the new features.

Time related functions don't using the Boost.Chrono library, use the chrono
overloads instead.

Breaking changes when BOOST_THREAD_VERSION==3:

There are some new features which share the same interface but with different
behavior. These breaking features are provided by default when BOOST_THREAD_VERSION
is 3, but the user can however choose the version 2 behavior by defining the
corresponding macro. As for the deprecated features, these broken features
will be only available until boost 1.55.

Almost every line of code in Boost.Thread
has been changed since the 1.34 release of boost. However, most of the interface
changes have been extensions, so the new code is largely backwards-compatible
with the old code. The new features and breaking changes are described below.

Condition variables can now be used with any type that implements the
Lockable concept, through the
use of boost::condition_variable_any (boost::condition is a typedef
to boost::condition_variable_any, provided for
backwards compatibility). boost::condition_variable
is provided as an optimization, and will only work with boost::unique_lock<boost::mutex> (boost::mutex::scoped_lock).

Thread IDs are separated from boost::thread, so a thread can obtain
it's own ID (using boost::this_thread::get_id()), and IDs can be used as keys in associative
containers, as they have the full set of comparison operators.

Timeouts are now implemented using the Boost DateTime library, through
a typedef boost::system_time for absolute timeouts, and
with support for relative timeouts in many cases. boost::xtime
is supported for backwards compatibility only.

Locks are implemented as publicly accessible templates boost::lock_guard,
boost::unique_lock, boost::shared_lock,
and boost::upgrade_lock, which are templated on
the type of the mutex. The Lockable concept has been extended
to include publicly available lock()
and unlock()
member functions, which are used by the lock types.

boost::detail::thread::lock_ops has been removed. Code that
relies on the lock_ops
implementation detail will no longer work, as this has been removed, as
it is no longer necessary now that mutex types now have public lock()
and unlock()
member functions.

scoped_lock constructors
with a second parameter of type bool
are no longer provided. With previous boost releases,

boost::mutex::scoped_locksome_lock(some_mutex,false);

could be used to create a lock object that was associated with a mutex,
but did not lock it on construction. This facility has now been replaced
with the constructor that takes a boost::defer_lock_type
as the second parameter:

boost::mutex::scoped_locksome_lock(some_mutex,boost::defer_lock);

The locked()
member function of the scoped_lock
types has been renamed to owns_lock().

You can no longer obtain a boost::thread instance representing the
current thread: a default-constructed boost::thread object is not associated
with any thread. The only use for such a thread object was to support the
comparison operators: this functionality has been moved to boost::thread::id.