| Home | Libraries | People | FAQ | More

## Changes since

#### Changes since boost 1.41

Fixed Bugs:

- #2309 Lack of g++ symbol visibility support in Boost.Thread.
- #2639 documentation should be extended(defer_lock, try_to_lock, ...).
- #3639 Boost.Thread doesn't build with Sun-5.9 on Linux.
- #3762 Thread can't be compiled with winscw (Codewarrior by Nokia).
- #3885 document about mix usage of boost.thread and native thread api.
- #3975 Incorrect precondition for promise::set_wait_callback().
- #4048 thread::id formatting involves locale
- #4315 gcc 4.4 Warning: inline ... declared as dllimport: attribute ignored.
- #4480 OpenVMS patches for compiler issues workarounds.
- #4819 boost.thread's documentation misprints.
- #5040 future.hpp in boost::thread does not compile with /clr.
- #5423 thread issues with C++0x.
- #5502 race condition between shared_mutex timed_lock and lock_shared.
- #5594 boost::shared_mutex not fully compatible with Windows CE.
- #5617 boost::thread::id copy ctor.
- #5739 set-but-not-used warnings with gcc-4.6.
- #5826 threads.cpp: resource leak on threads creation failure.
- #5839 thread.cpp: ThreadProxy leaks on exceptions.
- #5859 win32 shared_mutex constructor leaks on exceptions.
- #6100 Compute hardware_concurrency() using get_nprocs() on GLIBC systems.
- #6141 Compilation error when boost.thread and boost.move are used together.
- #6168 recursive_mutex is using wrong config symbol (possible typo).
- #6175 Compile error with SunStudio.
- #6200 patch to have condition_variable and mutex error better handle EINTR.
- #6207 shared_lock swap compiler error on clang 3.0 c++11.
- #6208 try_lock_wrapper swap compiler error on clang 3.0 c++11.

#### Changes since boost 1.40

The 1.41.0 release of Boost adds futures to the thread library. There are also a few minor changes.

#### Changes since boost 1.35

The 1.36.0 release of Boost includes a few new features in the thread library:

- New generic `lock()` and `try_lock()` functions for locking multiple mutexes at once.
- Rvalue reference support for move semantics where the compilers supports it.
- 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 `boost::thread` constructor.
- Backwards-compatibility overloads added for `timed_lock` and `timed_wait` functions to allow use of `xtime` for timeouts.

#### Changes since boost 1.34

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.

#### New Features

- Instances of `boost::thread` and of the various lock types are now movable.
- Threads can be interrupted at interruption points.
- 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.

#### Breaking Changes

The list below should cover all changes to the public interface which break backwards compatibility.

- `boost::try_mutex` has been removed, and the functionality subsumed into `boost::mutex`. `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_mutex`. `boost::recursive_try_mutex` is left as a `typedef`, but is no longer a separate class.
- `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_lock some_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_lock some_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`.
- The broken `boost::read_write_mutex` has been replaced with `boost::shared_mutex`.
- `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 `boost::condition_variable_any::wait()`, the mutex is only unlocked one level, and not completely. This prior behaviour was not guaranteed and did not feature in the tests.