Request for unlock_guard to compliment lock_guard.
Request for shared_mutex duration timed_lock and timed_lock_shared.
Proposal to manage portable and non portable thread attributes.
Request for shared_lock_guard.
Adapt to Boost.Move.
c++11 compliance: Provide the standard time related interface using Boost.Chrono.
Enhance Boost.Thread shared mutex interface following Howard Hinnant proposal.
c++11 compliance: Add the use of standard noexcept on compilers supporting
Add the use of standard =delete defaulted operations on compilers supporting
c++11 compliance: Add explicit bool conversion from locks.
Add promise constructor with allocator following the standard c++11.
Rename the unique_future to future following the c++11.
c++11 compliance: Follows the exception reporting mechanism as defined
in the c++11.
Add BasicLockable requirements in the documentation to follow c++11.
Breaking change: thread destructor should call terminate if joinable.
Breaking change: thread move assignment should call terminate if joinable.
c++11 compliance: Add thread::id hash specialization.
c++11 compliance: Add cv_status enum class and use it on the conditions
c++11 compliance: Adapt the one_flag to the c++11 interface.
upgrade_lock: missing mutex and release functions.
upgrade_lock:: missing constructors from time related types.
upgrade_lock:: missing non-member swap.
lock conversion should be explicit.
Added missing packaged_task::result_type and packaged_task:: constructor
boost::move from lvalue does not work with gcc.
shared_mutex for win32 doesn't have timed_lock_upgrade.
Bug- Boost 1.36.0 on Itanium platform.
Duplicate tutorial code in boost::thread.
thread::id and joining problem with cascade of threads.
Error using boost::move on packaged_task (MSVC 10).
Must use implementation details to return move-only types.
BOOST_THREAD_USE_DLL and BOOST_THREAD_USE_LIB are crucial and need to be
documentation: boost::thread: pthreas_exit causes terminate().
boost::this_thread::get_id is very slow.
interrupt a future get boost::unknown_exception.
Upgrade lock is not acquired when previous upgrade lock releases if another
read lock is present.
shared_future<T>::get() has wrong return type.
packaged_task doesn't correctly handle moving results.
Compile error with SunStudio: unique_future move.
PGI: Compiler threading support is not turned on.
shared_lock: move assign doesn't works with c++11.
shared_mutex: try_lock_upgrade_until doesn't works.
Compile error due to unprotected definitions of _WIN32_WINNT and WINVER.
TIME_UTC is a macro in C11.
call of abs is ambiguous.
Fix issue signaled on the ML with task_object(task_object const&) in
presence of task_object(task_object &&)
Lack of g++ symbol visibility support in Boost.Thread.
documentation should be extended(defer_lock, try_to_lock, ...).
Boost.Thread doesn't build with Sun-5.9 on Linux.
Thread can't be compiled with winscw (Codewarrior by Nokia).
document about mix usage of boost.thread and native thread api.
Incorrect precondition for promise::set_wait_callback().
thread::id formatting involves locale
gcc 4.4 Warning: inline ... declared as dllimport: attribute ignored.
OpenVMS patches for compiler issues workarounds.
boost.thread's documentation misprints.
thread issues with C++0x.
boost::thread::id copy ctor.
set-but-not-used warnings with gcc-4.6.
threads.cpp: resource leak on threads creation failure.
thread.cpp: ThreadProxy leaks on exceptions.
win32 shared_mutex constructor leaks on exceptions.
Compute hardware_concurrency() using get_nprocs() on GLIBC systems.
recursive_mutex is using wrong config symbol (possible typo).
Compile error with SunStudio.
patch to have condition_variable and mutex error better handle EINTR.
shared_lock swap compiler error on clang 3.0 c++11.
try_lock_wrapper swap compiler error on clang 3.0 c++11.
The 1.41.0 release of Boost adds futures to the thread library. There are also
a few minor changes.
The 1.36.0 release of Boost includes a few new features in the thread library:
functions for locking multiple mutexes at once.
Rvalue reference support for move semantics where the compilers supports
A few bugs fixed and missing functions added (including the serious win32
condition variable bug).
scoped_try_lock types are
now backwards-compatible with Boost 1.34.0 and previous releases.
Support for passing function arguments to the thread function by supplying
additional arguments to the
Backwards-compatibility overloads added for
to allow use of
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.
boost::thread and of the various lock
types are now movable.
Threads can be interrupted at interruption
Condition variables can now be used with any type that implements the
Lockable concept, through the
boost::condition is a
boost::condition_variable_any, provided for
is provided as an optimization, and will only work with
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
boost::system_time for absolute timeouts, and
with support for relative timeouts in many cases.
is supported for backwards compatibility only.
Locks are implemented as publicly accessible templates
boost::upgrade_lock, which are templated on
the type of the mutex. The
Lockable concept has been extended
to include publicly available
member functions, which are used by the lock types.
The list below should cover all changes to the public interface which break
boost::try_mutex has been removed, and
the functionality subsumed into
boost::try_mutex is left as a
typedef, but is no longer a separate class.
boost::recursive_try_mutex has been removed,
and the functionality subsumed into
boost::recursive_try_mutex is left as
typedef, but is no longer
a separate class.
boost::detail::thread::lock_ops has been removed. Code that
relies on the
implementation detail will no longer work, as this has been removed, as
it is no longer necessary now that mutex types now have public
with a second parameter of type
are no longer provided. With previous boost releases,
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
as the second parameter:
member function of the
types has been renamed to
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::read_write_mutex has been replaced with
boost::mutex is now never recursive.
For Boost releases prior to 1.35
boost::mutex was recursive on Windows
and not on POSIX platforms.
When using a
boost::recursive_mutex with a call to
the mutex is only unlocked one level, and not completely. This prior behaviour
was not guaranteed and did not feature in the tests.