Apply manualy fixes on develop concerning memory leak os tss and scoped_thread move assignement.

Fix compilation on Windows

build/Jamfile.v2

@@ -60,7 +60,8 @@ project boost/thread
         <toolset>gcc:<cxxflags>-Wno-long-long
         #<toolset>gcc:<cxxflags>-ansi
         #<toolset>gcc:<cxxflags>-fpermissive
-        <toolset>gcc:<cxxflags>-Wno-variadic-macros
+        <toolset>gcc-4:<cxxflags>-Wno-variadic-macros
+        <toolset>gcc-5:<cxxflags>-Wno-variadic-macros
         #<toolset>gcc:<cxxflags>-Wunused-local-typedefs
         <toolset>gcc:<cxxflags>-Wunused-function
         <toolset>gcc:<cxxflags>-Wno-unused-parameter
@@ -70,7 +71,9 @@ project boost/thread
         #<toolset>darwin:<cxxflags>-ansi
         <toolset>darwin:<cxxflags>-fpermissive
         <toolset>darwin:<cxxflags>-Wno-long-long
-        <toolset>darwin:<cxxflags>-Wno-variadic-macros
+        #<toolset>darwin:<cxxflags>-Wno-variadic-macros
+        <toolset>darwin-4:<cxxflags>-Wno-variadic-macros
+        <toolset>darwin-5:<cxxflags>-Wno-variadic-macros
         #<toolset>darwin:<cxxflags>-Wunused-local-typedefs
         <toolset>darwin:<cxxflags>-Wunused-function
         <toolset>darwin:<cxxflags>-Wno-unused-parameter

doc/async_executors.qbk

@@ -112,7 +112,7 @@ A question arises of which of these executors (or others) be included in this li
 [////////////////////////]
 [section:rationale Design Rationale]
 
-The authors of Boost.Thread have taken a different approach respect to N3785. Instead of basing all the design on a abstract executor class we make executor concepts. We believe that this is the good direction as a static polymorphic executor can be seen as a dynamic polymorphic executor using a simple adaptor. We believe also that it would make the library more usable, and more convenient for users.
+The authors of Boost.Thread have taken a different approach respect to N3785. Instead of basing all the design on an abstract executor class we make executor concepts. We believe that this is the good direction as a static polymorphic executor can be seen as a dynamic polymorphic executor using a simple adaptor. We believe also that it would make the library more usable, and more convenient for users.
 
 The major design decisions concern deciding what a unit of work is, how to manage with units of work and time related functions in a polymorphic way.
 
@@ -364,8 +364,8 @@ A type `E` meets the `Executor` requirements if the following expressions are we
 where 
 
 * `e` denotes a value of type `E`, 
-* `lc` denotes a lvalue referece of type `Closure`, 
-* `rc` denotes a rvalue referece of type `Closure`
+* `lc` denotes a lvalue reference of type `Closure`, 
+* `rc` denotes a rvalue reference of type `Closure`
 * `p` denotes a value of type `Predicate`
 
 [/////////////////////////////////////]
@@ -388,7 +388,7 @@ If invoked closure throws an exception the executor will call std::terminate, as
 
 [endsect]
 [/////////////////////////////////////]
-[section:submitrc `e.submit(lc);`]
+[section:submitrc `e.submit(rc);`]
 
 [variablelist
 
@@ -417,7 +417,7 @@ If invoked closure throws an exception the executor will call std::terminate, as
 
 [[Return type:] [`void`.]]
 
-[[Throws:] [Whatever exception that can be throw while ensuring the thread safety.]]
+[[Throws:] [Whatever exception that can be thrown while ensuring the thread safety.]]
 
 [[Exception safety:] [If an exception is thrown then the executor state is unmodified.]]
 
@@ -462,7 +462,7 @@ If invoked closure throws an exception the executor will call std::terminate, as
 
 [variablelist
 
-[[Requires:] [This must be called from an scheduled work]]
+[[Requires:] [This must be called from a scheduled work]]
 
 [[Effects:] [reschedule works until `p()`.]]
 
@@ -533,7 +533,7 @@ Executor abstract base class.
 
 [variablelist
 
-[[Effects:] [Constructs a executor. ]]
+[[Effects:] [Constructs an executor. ]]
 
 [[Throws:] [Nothing. ]]
 
@@ -600,7 +600,7 @@ Polymorphic adaptor of a model of Executor to an executor.
 
 [variablelist
 
-[[Effects:] [Constructs a executor_adaptor. ]]
+[[Effects:] [Constructs an executor_adaptor. ]]
 
 [[Throws:] [Nothing. ]]
 
@@ -1521,7 +1521,7 @@ A serial executor ensuring that there are no two work units that executes concur
 
 [variablelist
 
-[[Effects:] [Constructs a inline_executor. ]]
+[[Effects:] [Constructs an inline_executor. ]]
 
 [[Throws:] [Nothing. ]]
 
@@ -1709,7 +1709,7 @@ A user scheduled executor.
 
 [variablelist
 
-[[Effects:] [creates a executor that runs closures using one of its closure-executing methods. ]]
+[[Effects:] [creates an executor that runs closures using one of its closure-executing methods. ]]
 
 [[Throws:] [Whatever exception is thrown while initializing the needed resources. ]]
 

doc/changes.qbk

@@ -8,6 +8,34 @@
 
 [section:changes History]
 
+
+[heading Version 4.7.0 - boost 1.61]
+
+[*Know Bugs:]
+
+* [@http://svn.boost.org/trac/boost/ticket/3926 #3926] thread_specific_ptr + dlopen library causes a SIGSEGV.
+
+Please define BOOST_THREAD_PATCH to apply the patch that could unfortunately results is a regression as described in [@http://svn.boost.org/trac/boost/ticket/12049 #12049].
+
+* [@http://svn.boost.org/trac/boost/ticket/4833 #4833] MinGW/test_tss_lib: Support of automatic tss cleanup for native threading API not available
+* [@http://svn.boost.org/trac/boost/ticket/8600 #8600] wait_for_any hangs, if called with multiple copies of shared_future referencing same task
+* [@http://svn.boost.org/trac/boost/ticket/9118 #9118] Seg fault on thread join when llvm and libc++ are used
+
+Please take a look at [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=thread&type=!Feature+Requests&col=id&col=summary&order=id thread Know Bugs] to see the current state.
+
+Please take a look at [@http://www.boost.org/development/tests/master/developer/thread.html thread trunk regression test] to see the last regression test snapshot.
+
+[*New Experimental Features:]
+
+* [@http://svn.boost.org/trac/boost/ticket/11772 #11772] Add a launch::sync policy
+
+[*Fixed Bugs:]
+
+* [@http://svn.boost.org/trac/boost/ticket/11494 #11494] boost::this_thread::yield() is marked as deprecated in the synopsis
+* [@http://svn.boost.org/trac/boost/ticket/11562 #11562] (condition_variable_any::wait_until + recursive_mutex + steady_clock) timer expires after computer time is set forward on Ubuntu 64-bit
+* [@http://svn.boost.org/trac/boost/ticket/12013 #12013] F_pass and FArgs_pass tests segfault
+* [@http://svn.boost.org/trac/boost/ticket/12036 #12036] boost::physical_concurrency always returns 0 if BOOST_USE_WINAPI_VERSION is not defined
+
 [heading Version 4.6.0 - boost 1.60]
 
 [*Know Bugs:]
@@ -23,11 +51,16 @@ Please take a look at [@http://www.boost.org/development/tests/master/developer/
 
 [*New Experimental Features:]
 
+
+* [@http://svn.boost.org/trac/boost/ticket/11231 #11231] Allow to set continuation future's destructor behavior to non-blocking
 * [@http://svn.boost.org/trac/boost/ticket/11424 #11424] Provide shared_timed_mutex as an alternative name for shared_mutex and deprecate the use of shared_mutex as a timed mutex
+* [@http://svn.boost.org/trac/boost/ticket/11734 #11734] future::then(Cont) should be able to execute the continuation on undetermined thread
+* [@http://svn.boost.org/trac/boost/ticket/11736 #11736] Allow to use launch::executor on future::then(launch::executor, cont)
+* [@http://svn.boost.org/trac/boost/ticket/11737 #11737] Add a launch::inherit policy that can be used on ::then() to use the policy of the parent future
+
 
 [*Fixed Bugs:]
 
-* [@http://svn.boost.org/trac/boost/ticket/3926 #3926] thread_specific_ptr + dlopen library causes a SIGSEGV.
 * [@http://svn.boost.org/trac/boost/ticket/6377 #6377] Condition variable blocks when changing time
 * [@http://svn.boost.org/trac/boost/ticket/6787 #6787] boost::thread::sleep() hangs if system time is rolled back
 * [@http://svn.boost.org/trac/boost/ticket/7665 #7665] this_thread::sleep_for no longer uses steady_clock in thread
@@ -35,23 +68,33 @@ Please take a look at [@http://www.boost.org/development/tests/master/developer/
 * [@http://svn.boost.org/trac/boost/ticket/9309 #9309] test_latch fails often on clang-darwin-tot11
 * [@http://svn.boost.org/trac/boost/ticket/10788 #10788] GetLogicalProcessor isn't available for Windows platform less or equals to 0x0502
 * [@http://svn.boost.org/trac/boost/ticket/11090 #11090] ex_future_unwrap- ThreadSanitizer: lock-order-inversion (potential deadlock)
+* [@http://svn.boost.org/trac/boost/ticket/11158 #11158] Pthread thread deadlock when faketime used
+* [@http://svn.boost.org/trac/boost/ticket/11174 #11174] boost::condition_variable::timed_wait with predicate unexpectedly wakes up while should wait infinite
 * [@http://svn.boost.org/trac/boost/ticket/11185 #11185] Incorrect URL redirection
 * [@http://svn.boost.org/trac/boost/ticket/11192 #11192] boost::future<>::then() with an executor doesn't compile when the callback returns a future
 * [@http://svn.boost.org/trac/boost/ticket/11250 #11250] future made from make_exceptional fails on assertion in destructor
 * [@http://svn.boost.org/trac/boost/ticket/11256 #11256] future<>::is_ready() == false in continuation function
-* [@http://svn.boost.org/trac/boost/ticket/11158 #11158] Pthread thread deadlock when faketime used
 * [@http://svn.boost.org/trac/boost/ticket/11261 #11261] bad use of scoped threads in basic_thread_pool
+* [@http://svn.boost.org/trac/boost/ticket/11262 #11262] bad use of direct pointer in shared_state_nullary_task
 * [@http://svn.boost.org/trac/boost/ticket/11263 #11263] lock already locked lock
 * [@http://svn.boost.org/trac/boost/ticket/11266 #11266] boost::packaged_task has invalid variadic signature
 * [@http://svn.boost.org/trac/boost/ticket/11302 #11302] boost thread doesn't build with BOOST_THREAD_PATCH.
 * [@http://svn.boost.org/trac/boost/ticket/11322 #11322] sleep_for() nanoseconds overload will always return too early on windows
 * [@http://svn.boost.org/trac/boost/ticket/11329 #11329] using declarative for GetProcessHeap, .... fails
+* [@http://svn.boost.org/trac/boost/ticket/11368 #11368] boost thread's usage of CreateWaitableTimer wakes PC from sleep (doh)
 * [@http://svn.boost.org/trac/boost/ticket/11377 #11377] Boost condition variable always waits for system clock deadline
 * [@http://svn.boost.org/trac/boost/ticket/11435 #11435] gcc compiler warning in future.hpp
 * [@http://svn.boost.org/trac/boost/ticket/11555 #11555] devector.hpp assumes allocator_traits_type is always present
-* [@http://svn.boost.org/trac/boost/ticket/11562 #11562] Timer (using steady_clock) expires after computer time is set forward on Ubuntu 64-bit
+* [@http://svn.boost.org/trac/boost/ticket/11562 #11562] (condition_variable_any::wait_until + recursive_mutex + steady_clock) timer expires after computer time is set forward on Ubuntu 64-bit
 * [@http://svn.boost.org/trac/boost/ticket/11672 #11672] Thread: Should use unique_ptr, not auto_ptr
+* [@http://svn.boost.org/trac/boost/ticket/11688 #11688] thread::try_join_until: Avoid busy wait if system clock changes
+* [@http://svn.boost.org/trac/boost/ticket/11672 #11716] ::then(f) should inherit the parent Executor
+* [@http://svn.boost.org/trac/boost/ticket/11795 #11795] Incorrect version specification for documentation of thread destructor
+* [@http://svn.boost.org/trac/boost/ticket/11796 #11796] Thread move assignment operator, does not detach previous thread data
+* [@http://svn.boost.org/trac/boost/ticket/11817 #11817] 'sync_queue_is_closed' was not declared in boost/thread/executors/thread_executor.hpp
+* [@http://svn.boost.org/trac/boost/ticket/11818 #11818] future.then will be blocked if promise is set after the invocation of then
 
+* [@http://svn.boost.org/trac/boost/ticket/12049 #12049] Assertion failure from detached threads during shutdown
 
 [heading Version 4.5.0 - boost 1.58]
 

doc/configuration.qbk

@@ -81,7 +81,7 @@ When `BOOST_THREAD_VERSION>3`  && defined BOOST_THREAD_PLATFORM_PTHREAD define `
 
 [section:move  Boost.Atomic]
 
-Boost.Thread uses by default an Boost.Atomic in POSIX platforms to implement call_once..
+Boost.Thread uses by default Boost.Atomic in POSIX platforms to implement call_once..
 
 Define `BOOST_THREAD_USES_ATOMIC ` if you want to use Boost.Atomic.
 Define `BOOST_THREAD_DONT_USE_ATOMIC ` if you don't want to use Boost.Atomic or if it is not supported in your platform.

doc/emulations.qbk

@@ -267,7 +267,7 @@ The library provides un implicit conversion to an undefined type that can be use
         explicit operator bool() const;
     #endif
 
-The user should use the lock.owns_lock() when a explicit conversion is required. 
+The user should use the lock.owns_lock() when an explicit conversion is required. 
 
 [section:bool_conversion `operator `['unspecified-bool-type]`() const`]
 
@@ -324,7 +324,7 @@ the library declare these types as
   }
   BOOST_SCOPED_ENUM_DECLARE_END(future_errc)
 
-These macros allows to use 'future_errc' in almost all the cases as an scoped enum.
+These macros allows to use 'future_errc' in almost all the cases as a scoped enum.
 
 There are however some limitations:
 

doc/future_ref.qbk

@@ -29,9 +29,11 @@
 
     enum class launch
     {
+      none = unspecified,
       async = unspecified,
       deferred = unspecified,
       executor = unspecified,
+      inherit = unspecified,
       any = async | deferred
     };
     
@@ -165,14 +167,27 @@
 
     enum class launch
     {
+      none = unspecified,
       async = unspecified,
       deferred = unspecified,
       executor = unspecified,
+      inherit = unspecified,
       any = async | deferred
     };
 
 The enum type launch is a bitmask type with launch::async and launch::deferred denoting individual bits. 
 
+A future created with `promise<>` or with a `packaged_task<>` or with `make_ready_future`/`make_exceptional_future` (has no associated launch policy), has an implicit a launch policy of `launch::none`.
+
+A future created by `async(launch::async, ...)` or `::then(launch::async, ...)` has associated a launch policy `launch::async`.
+A future created by `async(launch::deferred, ...)` or `::then(launch::deferred, ...)` has associated a launch policy `launch::deferred`.
+A future created by `async(Executor, ...)`  or `::then(Executor, ...)` or `::then(launch::executor, ...)` has associated a launch policy `launch::executor`.
+A future created by `async(...)`  or `::then(...)` has associated a launch policy `launch::none`.
+
+A future created by `::then(launch::inherit, ...)` has associated a launch policy parent future.
+
+The `executor` and the `inherit` launch policies have a sense only can be user only on `then()`.
+
 [endsect]
 [///////////////////////////////////////////////////////////////////////////]
 [section:is_error_code_enum Specialization `is_error_code_enum<future_errc>`]
@@ -833,7 +848,7 @@ stored exception, `false` otherwise.]]
 [[Effects:] [If `*this` is associated with a shared state, waits until the result is ready. If the result is not ready on
 entry, and the result has a ['wait callback] set, that callback is invoked prior to waiting.]]
 
-[[Returns:] [a exception_ptr, storring or not an exception.]]
+[[Returns:] [an exception_ptr, storing or not an exception.]]
 
 [[Remarks:] [The result of this function is not stable and the future could lost its exception even if the function returned a valid `exception_ptr` or vice-versa.]]
 
@@ -898,29 +913,41 @@ There are not too much tests yet, so it is possible that you can find out some t
 [variablelist
 
 [[Notes:] [The three functions differ only by input parameters. The first only takes a callable object which accepts a 
-future object as a parameter. The second function takes a executor as the first parameter and a callable object as 
+future object as a parameter. The second function takes an executor as the first parameter and a callable object as 
 the second parameter. The third function takes a launch policy as the first parameter and a callable object as the 
 second parameter.]]
 
+[[Requires:] [`INVOKE(DECAY_COPY (std::forward<F>(func)), std::move(*this))` shall be a valid expression.]]
+
 [[Effects:] [
 
-All the functions create a shared state that is associated with the returned future object. The further behavior of the functions is as follows. 
+All the functions create a shared state that is associated with the returned future object. Additionally,
 
-- The continuation is called when the object's shared state is ready (has a value or exception stored).
+- When the object's shared state is ready, the continuation
+`INVOKE(DECAY_COPY(std::forward<F>(func)), std::move(*this))` is called depending on the overload (see below) with the call to DECAY_COPY() being evaluated in the thread that called then.
 
-- The continuation launches according to the specified policy or executor.
+- Any value returned from the continuation is stored as the result in the shared state of the resulting `future`. 
+Any exception propagated from the execution of the continuation is stored as the exceptional result in the shared state of the resulting `future`. 
 
-- When the executor or launch policy is not provided the continuation inherits the
-parent's launch policy or executor.
 
-- Any value returned from the continuation is stored as the result in the shared state of the resulting `future`. Any exception propagated from the execution of the continuation is stored as the exceptional result in the shared state of the resulting `future`. 
+The continuation launches according to the specified policy or executor or noting.
 
-- If the parent was created with `promise<>` or with a `packaged_task<>` (has no associated launch policy), the 
-continuation behaves the same as the third overload with a policy argument of `launch::async | launch::deferred` and 
-the same argument for `func`.
+- When the launch policy is `launch::none` the continuation is called on an unspecified thread of execution.
 
-- If the parent has a policy of `launch::deferred` and the continuation does not have a specified launch policy or 
-scheduler, then the parent is filled by immediately calling `.wait()`, and the policy of the antecedent is 
+- When the launch policy is `launch::async` the continuation is called on a new thread of execution.
+
+- When the launch policy is `launch::deferred` the continuation is called on demand.
+
+- When the launch policy is `launch::executor` the continuation is called on one of the thread of execution of the executor.
+
+- When the launch policy is `launch::inherit` the continuation inherits the parent's launch policy or executor.
+
+- When the executor or launch policy is not provided (first overload) is if as if launch::none was specified.
+
+- When the executor is provided (second overload) the continuation is called on one of the thread of execution of the executor.
+
+- If the parent has a policy of `launch::deferred` and the continuation does not have a specified launch policy
+executor, then the parent is filled by immediately calling `.wait()`, and the policy of the antecedent is 
 `launch::deferred`.
 
 ]]
@@ -1330,7 +1357,7 @@ stored exception, `false` otherwise.]]
 [[Effects:] [If `*this` is associated with a shared state, waits until the result is ready. If the result is not ready on
 entry, and the result has a ['wait callback] set, that callback is invoked prior to waiting.]]
 
-[[Returns:] [a exception_ptr, storring or not an exception.]]
+[[Returns:] [an exception_ptr, storing or not an exception.]]
 
 [[Throws:] [Whatever `mutex::lock()/mutex::unlock()` can throw.]]
 
@@ -1380,22 +1407,38 @@ shared_future object as a parameter. The second function takes an executor as th
 the second parameter. The third function takes a launch policy as the first parameter and a callable object as the 
 second parameter.]]
 
+[[Requires:] [`INVOKE(DECAY_COPY (std::forward<F>(func)), *this)` shall be a valid expression.]]
+
 [[Effects:] [
 
-- The continuation is called when the object's shared state is ready (has a value or exception stored).
+All the functions create a shared state that is associated with the returned future object. Additionally,
 
-- The continuation launches according to the specified policy or executor.
+- When the object's shared state is ready, the continuation
+`INVOKE(DECAY_COPY(std::forward<F>(func)), *this)` is called depending on the overload (see below) with the call to DECAY_COPY() being evaluated in the thread that called then.
 
-- When the executor or launch policy is not provided the continuation inherits the
-parent's launch policy or executor.
+- Any value returned from the continuation is stored as the result in the shared state of the resulting `future`. 
+Any exception propagated from the execution of the continuation is stored as the exceptional result in the shared state of the resulting `future`. 
 
-- If the parent was created with `promise` or with a `packaged_task` (has no associated launch policy), the 
-continuation behaves the same as the third overload with a policy argument of `launch::async | launch::deferred` and 
-the same argument for func.
 
-- If the parent has a policy of `launch::deferred` and the continuation does not have a specified launch policy or 
+The continuation launches according to the specified policy or executor or noting.
+
+- When the launch policy is `launch::none` the continuation is called on an unspecified thread of execution.
+
+- When the launch policy is `launch::async` the continuation is called on a new thread of execution.
+
+- When the launch policy is `launch::deferred` the continuation is called on demand.
+
+- When the launch policy is `launch::executor` the continuation is called on one of the thread of execution of the executor.
+
+- When the launch policy is `launch::inherit` the continuation inherits the parent's launch policy or executor.
+
+- When the executor or launch policy is not provided (first overload) is if as if launch::none was specified.
+
+- When the executor is provided (second overload) the continuation is called on one of the thread of execution of the executor.
+
+- If the parent has a policy of `launch::deferred` and the continuation does not have a specified launch policy
 executor, then the parent is filled by immediately calling `.wait()`, and the policy of the antecedent is 
-`launch::deferred`
+`launch::deferred`.
 
 ]]
 

doc/futures.qbk

@@ -326,7 +326,7 @@ Using a `shared_future` solves the issue
 
 [heading share()]
   
-Namming the return type when declaring the `shared_future` is needed; auto is not available within template argument lists. 
+Naming the return type when declaring the `shared_future` is needed; auto is not available within template argument lists. 
 Here `share()` could be used to simplify the code
 
   void better_second_use( type arg ) {
@@ -344,7 +344,7 @@ Here `share()` could be used to simplify the code
  
 [heading Writing on get()]
 
-The user can either read or write the future avariable. 
+The user can either read or write the future variable. 
 
   void write_to_get( type arg ) {
       
@@ -365,7 +365,7 @@ The user can either read or write the future avariable.
 This works because the `shared_future<>::get()` function returns a non-const reference to the appropriate storage.
 Of course the access to this storage must be ensured by the user. The library doesn't ensure the access to the internal storage is thread safe.
 
-There has been some work by the C++ standard committe on an `atomic_future` that behaves as an `atomic` variable, that is is thread_safe, 
+There has been some work by the C++ standard committee on an `atomic_future` that behaves as an `atomic` variable, that is thread_safe, 
 and a `shared_future` that can be shared between several threads, but there were not enough consensus and time to get it ready for C++11.       
 
 [endsect]
@@ -444,7 +444,7 @@ Input Parameters:
 success and one for error handling. However this option has not been retained for the moment. 
 The lambda function takes a future as its input which carries the exception 
 through. This makes propagating exceptions straightforward. This approach also simplifies the chaining of continuations.
-* Executor: Providing an overload to `.then`, to take a executor reference places great flexibility over the execution 
+* Executor: Providing an overload to `.then`, to take an executor reference places great flexibility over the execution 
 of the future in the programmer's hand. As described above, often taking a launch policy is not sufficient for powerful 
 asynchronous operations. The lifetime of the executor must outlive the continuation.
 * Launch policy: if the additional flexibility that the executor provides is not required.

doc/internal_locking.qbk

@@ -240,9 +240,9 @@ The following class describes a so-called monitor pattern.
   template <
       typename Lockable=mutex
   >
-  class basic_monitor : protected basic_lockable_adapter<Lockable> { // behaves like an BasicLockable for the derived classes 
+  class basic_monitor : protected basic_lockable_adapter<Lockable> { // behaves like a BasicLockable for the derived classes 
   protected:
-      typedef unspecified synchronizer; // is an strict lock guard 
+      typedef unspecified synchronizer; // is a strict lock guard 
   };
 
 [/shared_monitor]

doc/mutex_concepts.qbk

@@ -869,7 +869,7 @@ any other threads have shared ownership, blocks until exclusive ownership can be
 
 [variablelist
 
-[[Precondition:] [The calling thread shall hold a upgrade lock on the mutex.]]
+[[Precondition:] [The calling thread shall hold an upgrade lock on the mutex.]]
 
 [[Effects:] [The function attempts to atomically convert the ownership from upgrade to exclusive for the calling thread without blocking. 
 For this conversion to be successful, this thread must be the only thread holding any ownership of the lock. 
@@ -893,7 +893,7 @@ If the conversion is not successful, the upgrade ownership of m is retained.]]
 
 [variablelist
 
-[[Precondition:] [The calling thread shall hold a upgrade lock on the mutex.]]
+[[Precondition:] [The calling thread shall hold an upgrade lock on the mutex.]]
 
 [[Effects:] [If the tick period of `rel_time` is not exactly convertible to the native tick period, the duration shall be rounded up to the nearest native tick period. 
 The function attempts to atomically convert the ownership from upgrade to exclusive for the calling thread within the relative timeout specified by `rel_time`. 
@@ -919,7 +919,7 @@ If the conversion is not successful, the upgrade ownership of m is retained.]]
 
 [variablelist
 
-[[Precondition:] [The calling thread shall hold a upgrade lock on the mutex.]]
+[[Precondition:] [The calling thread shall hold an upgrade lock on the mutex.]]
 
 [[Effects:] [The function attempts to atomically convert the ownership from upgrade to exclusive for the calling thread within the absolute timeout specified by `abs_time`. 
 If `abs_time` has already passed, the function attempts to obtain exclusive ownership without blocking (as if by calling `__try_unlock_upgrade_and_lock()`). 
@@ -2150,7 +2150,7 @@ object passed to the constructor.]]
 __nested_strict_lock is a model of __StrictLock.
 
 A nested strict lock is a scoped lock guard ensuring a mutex is locked on its
-scope, by taking ownership of an nesting lock, locking the mutex on construction if not already locked
+scope, by taking ownership of a nesting lock, locking the mutex on construction if not already locked
 and restoring the ownership to the nesting lock on destruction.
  
 

doc/scoped_thread.qbk

@@ -150,7 +150,7 @@ This wrapper can be used to join the thread before destroying it.
 
 [variablelist
 
-[[Effects:] [Construct a internal thread in place.]]
+[[Effects:] [Construct an internal thread in place.]]
 
 [[Postconditions:] [`*this.t_` refers to the newly created thread of execution and `this->get_id()!=thread::id()`.]]
 

doc/sync_queues_ref.qbk

@@ -110,10 +110,10 @@ where
 * `q` denotes a value of type `Q`, 
 * `e` denotes a value of type Q::value_type, 
 * `u` denotes a value of type Q::size_type, 
-* `lve` denotes a lvalue referece of type Q::value_type, 
-* `rve` denotes a rvalue referece of type Q::value_type:
+* `lve` denotes an lvalue reference of type Q::value_type, 
+* `rve` denotes an rvalue reference of type Q::value_type:
 [/* `spe` denotes a shared_ptr<Q::value_type>]
-* `qs` denotes a variable of of type `queus_op_status`, 
+* `qs` denotes a variable of of type `queue_op_status`, 
 
 
 [/////////////////////////////////////]
@@ -246,8 +246,8 @@ where
 * `e` denotes a value of type `Q::value_type`, 
 * `s` denotes a value of type `queue_status`, 
 * `u` denotes a value of type `Q::size_type`, 
-* `lve` denotes a lvalue referece of type Q::value_type, 
-* `rve` denotes a rvalue referece of type Q::value_type:
+* `lve` denotes an lvalue reference of type Q::value_type, 
+* `rve` denotes an rvalue reference of type Q::value_type:
 [/* `spe` denotes a shared_ptr<Q::value_type>]
 
 
@@ -357,8 +357,8 @@ where
 * `q` denotes a value of type `Q`, 
 * `e` denotes a value of type Q::value_type, 
 * `s` denotes a value of type `queue_status`, 
-* `lve` denotes a lvalue referece of type Q::value_type, 
-* `rve` denotes a rvalue referece of type Q::value_type:
+* `lve` denotes an lvalue reference of type Q::value_type, 
+* `rve` denotes an rvalue reference of type Q::value_type:
 [/* `spe` denotes a shared_ptr<Q::value_type>]
 
 
@@ -545,7 +545,7 @@ Closed queues add the following valid expressions
 
 [[Return:] [
 
-- If the queue is closed retun `queue_op_status::closed`,
+- If the queue is closed return `queue_op_status::closed`,
 
 - otherwise, return `queue_op_status::success` if no exception is thrown.
 

doc/sync_streams.qbk

@@ -156,7 +156,7 @@ object passed to the constructor.]]
     };
   }
 
-`externally_locked_stream` cloaks a reference to an stream of type `Stream`, and actually
+`externally_locked_stream` cloaks a reference to a stream of type `Stream`, and actually
 provides full access to that object through the `get` member functions, provided you
 pass a reference to a strict lock object.
 

doc/synchronized_value.qbk

@@ -63,7 +63,7 @@ Both forms of pointer dereference return a proxy object rather than a real refer
 
 The pointer-like semantics work very well for simple accesses such as assignment and calls to member functions. However, sometimes you need to perform an operation that requires multiple accesses under protection of the same lock, and that's what the synchronize() method provides.
 
-By calling synchronize() you obtain an strict_lock_ptr object that holds a lock on the mutex protecting the data, and which can be used to access the protected data. The lock is held until the strict_lock_ptr object is destroyed, so you can safely perform multi-part operations. The strict_lock_ptr object also acts as a pointer-to-T, just like synchronized_value does, but this time the lock is already held. For example, the following function adds a trailing slash to a path held in a synchronized_value. The use of the strict_lock_ptr object ensures that the string hasn't changed in between the query and the update.
+By calling synchronize() you obtain a strict_lock_ptr object that holds a lock on the mutex protecting the data, and which can be used to access the protected data. The lock is held until the strict_lock_ptr object is destroyed, so you can safely perform multi-part operations. The strict_lock_ptr object also acts as a pointer-to-T, just like synchronized_value does, but this time the lock is already held. For example, the following function adds a trailing slash to a path held in a synchronized_value. The use of the strict_lock_ptr object ensures that the string hasn't changed in between the query and the update.
 
   void addTrailingSlashIfMissing(boost::synchronized_value<std::string> & path)
   {

doc/thread.qbk

@@ -8,7 +8,7 @@
 
 [library Thread
     [quickbook 1.5]
-    [version 4.5.0]
+    [version 4.7.0]
     [authors [Williams, Anthony] [Botet Escriba, Vicente J.]]
     [copyright 2007-11 Anthony Williams]
     [copyright 2011-15 Vicente J. Botet Escriba]

doc/thread_ref.qbk

@@ -21,7 +21,7 @@
     {
       thread::id get_id() noexcept;
       template<typename TimeDuration>
-      void yield() noexcept; // DEPRECATED
+      void yield() noexcept;
       template <class Clock, class Duration>
       void sleep_until(const chrono::time_point<Clock, Duration>& abs_time); 
       template <class Rep, class Period>
@@ -255,7 +255,7 @@ does not complete when the specified time has elapsed or reached respectively.
 
 [endsect]
 
-[section:destructor1 Destructor V1]
+[section:destructor1 Destructor V1-2]
 
 When the __thread__ object that represents a thread of execution is destroyed the thread becomes ['detached]. Once a thread is
 detached, it will continue executing until the invocation of the function or callable object supplied on construction has completed,
@@ -264,7 +264,7 @@ object. In this case, the __thread__ object ceases to represent the now-detached
 
 [endsect]
 
-[section:destructor2 Destructor V2]
+[section:destructor2 Destructor V3-X]
 
 When the __thread__ object that represents a thread of execution is destroyed the program terminates if the thread is __joinable__. 
 
@@ -280,7 +280,7 @@ You can use a thread_joiner to ensure that the thread has been joined at the thr
   {
     boost::thread t(my_func);
     boost::thread_joiner g(t);
-    // do someting else
+    // do something else
   } // here the thread_joiner destructor will join the thread before it is destroyed.
 
 [endsect]
@@ -410,7 +410,7 @@ Of course all the synchronization facilities provided by Boost.Thread are also a
 
 The `boost::this_thread` interrupt related functions behave in a degraded mode when called from a thread created using the native interface, i.e. `boost::this_thread::interruption_enabled()` returns false. As consequence the use of `boost::this_thread::disable_interruption` and `boost::this_thread::restore_interruption` will do nothing and calls to `boost::this_thread::interruption_point()` will be just ignored.  
 
-As the single way to interrupt a thread is through a __thread__ instance, `interruption_request()` wiil returns false for the native threads. 
+As the single way to interrupt a thread is through a __thread__ instance, `interruption_request()` will return false for the native threads. 
 
 [heading `pthread_exit` POSIX limitation]
 
@@ -711,7 +711,7 @@ are copied into internal storage for access by the new thread.]]]
 
 [[Throws:] [Nothing.]]
 
-[[Note:] [The reason to moving to std::terminate is that either implicitly detaching or joining a `joinable()` thread in its destructor could result in difficult to debug correctness (for `detach`) or performance (for `join`) bugs encountered only when an exception is raised. Thus the programmer must ensure that the destructor is never executed while the thread is still joinable. Join the thread before destroying or use an scoped thread.]]
+[[Note:] [The reason to moving to std::terminate is that either implicitly detaching or joining a `joinable()` thread in its destructor could result in difficult to debug correctness (for `detach`) or performance (for `join`) bugs encountered only when an exception is raised. Thus the programmer must ensure that the destructor is never executed while the thread is still joinable. Join the thread before destroying or use a scoped thread.]]
 
 ]
 
@@ -964,7 +964,7 @@ predefined __interruption_points__ with interruption enabled .]]
 
 [section:hardware_concurrency Static member function `hardware_concurrency()`]
 
-    unsigned hardware_concurrency() noexecpt;
+    unsigned hardware_concurrency() noexcept;
 
 [variablelist
 
@@ -979,7 +979,7 @@ or 0 if this information is not available.]]
 
 [section:physical_concurrency Static member function `physical_concurrency()`]
 
-    unsigned physical_concurrency() noexecpt;
+    unsigned physical_concurrency() noexcept;
 
 [variablelist
 
@@ -1290,7 +1290,7 @@ instances of __thread_id__ `a` and `b` is the same if `a==b`, and different if `
 
 [variablelist
 
-[[Effects:] [Constructs a thread atrributes instance with its default values.]]
+[[Effects:] [Constructs a thread attributes instance with its default values.]]
 
 [[Throws:] [Nothing]]
 
@@ -1304,7 +1304,7 @@ instances of __thread_id__ `a` and `b` is the same if `a==b`, and different if `
 
 [variablelist
 
-[[Effects:] [Stores the stack size to be used to create a thread. This is an hint that the implementation can choose a better size if to small or too big or not aligned to a page.]]
+[[Effects:] [Stores the stack size to be used to create a thread. This is a hint that the implementation can choose a better size if to small or too big or not aligned to a page.]]
 
 [[Postconditions:] [`this-> get_stack_size()` returns the chosen stack size.]]
 
@@ -1532,7 +1532,7 @@ do not throw exceptions. __thread_interrupted__ if the current thread of executi
 
 [variablelist
 
-[[Effects:] [Suspends the current thread until the duration specified by
+[[Effects:] [Suspends the current thread until the duration specified
 by `rel_time` has elapsed.]]
 
 [[Throws:] [Nothing if operations of chrono::duration<Rep, Period> do not throw exceptions. __thread_interrupted__ if the current thread of execution is interrupted.]]

example/executor.cpp

@@ -7,6 +7,7 @@
 #if ! defined  BOOST_NO_CXX11_DECLTYPE
 #define BOOST_RESULT_OF_USE_DECLTYPE
 #endif
+#include <iostream>
 
 #define BOOST_THREAD_VERSION 4
 #define BOOST_THREAD_PROVIDES_EXECUTORS
@@ -48,8 +49,9 @@ void p2()
 
 int f1()
 {
-  // std::cout << BOOST_CONTEXTOF << std::endl;
+  std::cout << BOOST_CONTEXTOF << std::endl;
   boost::this_thread::sleep_for(boost::chrono::seconds(1));
+  std::cout << BOOST_CONTEXTOF << std::endl;
   return 1;
 }
 int f2(int i)
@@ -78,61 +80,95 @@ void at_th_entry(boost::basic_thread_pool& )
 
 int test_executor_adaptor()
 {
-  // std::cout << BOOST_CONTEXTOF << std::endl;
+  std::cout << BOOST_CONTEXTOF << std::endl;
   {
     try
     {
       {
         boost::executor_adaptor < boost::basic_thread_pool > ea(4);
+        std::cout << BOOST_CONTEXTOF << std::endl;
         submit_some( ea);
+        std::cout << BOOST_CONTEXTOF << std::endl;
+#if 1
+      // fixme
+      // ERROR= tr1::bad_weak_ptr
         {
           boost::future<int> t1 = boost::async(ea, &f1);
           boost::future<int> t2 = boost::async(ea, &f1);
-          // std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
-          // std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
+          std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
+          std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
         }
+        std::cout << BOOST_CONTEXTOF << std::endl;
         submit_some(ea);
+        std::cout << BOOST_CONTEXTOF << std::endl;
         {
           boost::basic_thread_pool ea3(1);
+          std::cout << BOOST_CONTEXTOF << std::endl;
           boost::future<int> t1 = boost::async(ea3, &f1);
+          std::cout << BOOST_CONTEXTOF << std::endl;
           boost::future<int> t2 = boost::async(ea3, &f1);
+          std::cout << BOOST_CONTEXTOF << std::endl;
           //boost::future<int> t2 = boost::async(ea3, f2, 1); // todo this doesn't compiles yet on C++11
           //boost::future<int> t2 = boost::async(ea3, boost::bind(f2, 1)); // todo this doesn't compiles yet on C++98
-          // std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
-          // std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
+          std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
+          std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
         }
+#endif
+        std::cout << BOOST_CONTEXTOF << std::endl;
         submit_some(ea);
+        std::cout << BOOST_CONTEXTOF << std::endl;
       }
-      // std::cout << BOOST_CONTEXTOF << std::endl;
+      std::cout << BOOST_CONTEXTOF << std::endl;
       {
         boost::executor_adaptor < boost::loop_executor > ea2;
         submit_some( ea2);
         ea2.underlying_executor().run_queued_closures();
       }
 #if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-      // std::cout << BOOST_CONTEXTOF << std::endl;
+      std::cout << BOOST_CONTEXTOF << std::endl;
       {
         boost::executor_adaptor < boost::basic_thread_pool > ea1(4);
         boost::executor_adaptor < boost::serial_executor > ea2(ea1);
         submit_some(ea2);
       }
 #endif
-      // std::cout << BOOST_CONTEXTOF << std::endl;
+      std::cout << BOOST_CONTEXTOF << std::endl;
       {
         boost::executor_adaptor < boost::inline_executor > ea1;
         submit_some(ea1);
       }
-      // std::cout << BOOST_CONTEXTOF << std::endl;
+      std::cout << BOOST_CONTEXTOF << std::endl;
       {
         boost::executor_adaptor < boost::thread_executor > ea1;
         submit_some(ea1);
       }
-      // std::cout << BOOST_CONTEXTOF << std::endl;
+      std::cout << BOOST_CONTEXTOF << std::endl;
+#if 1
+      // fixme
+      // ERROR= tr1::bad_weak_ptr
       {
         boost::basic_thread_pool  ea(4, at_th_entry);
         boost::future<int> t1 = boost::async(ea, &f1);
-        // std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
+        std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
       }
+#endif
+      std::cout << BOOST_CONTEXTOF << std::endl;
+      {
+        boost::async(&f1);
+      }
+#if 1
+      // fixme
+      // ERROR= tr1::bad_weak_ptr
+
+      std::cout << BOOST_CONTEXTOF << std::endl;
+      {
+        boost::basic_thread_pool  ea(1);
+        boost::async(ea,&f1);
+      }
+#endif
+      std::cout << BOOST_CONTEXTOF << std::endl;
+      boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
+      std::cout << BOOST_CONTEXTOF << std::endl;
     }
     catch (std::exception& ex)
     {

example/future_unwrap.cpp

@@ -41,10 +41,28 @@ int main()
   for (int i=0; i< number_of_tests; i++)
   try
   {
-    boost::future<boost::future<int> > outer_future = boost::async(boost::launch::async, &p2);
-    boost::future<int> inner_future = outer_future.unwrap();
-    int ii = inner_future.get();
-    BOOST_THREAD_LOG << "ii= "<< ii << "" << BOOST_THREAD_END_LOG;
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    {
+      boost::future<int> inner_future = boost::async(boost::launch::async, &p2);
+      inner_future.wait();
+      int ii = inner_future.get();
+      BOOST_THREAD_LOG << "ii= "<< ii << "" << BOOST_THREAD_END_LOG;
+    }
+#endif
+    {
+      boost::future<boost::future<int> > outer_future = boost::async(boost::launch::async, &p2);
+      boost::future<int> inner_future = outer_future.unwrap();
+      inner_future.wait();
+      int ii = inner_future.get();
+      BOOST_THREAD_LOG << "ii= "<< ii << "" << BOOST_THREAD_END_LOG;
+    }
+    {
+      boost::future<boost::future<int> > outer_future = boost::async(boost::launch::async, &p2);
+      boost::future<int> inner_future = outer_future.unwrap();
+      int ii = inner_future.get();
+      BOOST_THREAD_LOG << "ii= "<< ii << "" << BOOST_THREAD_END_LOG;
+    }
   }
   catch (std::exception& ex)
   {

example/generic_executor_ref.cpp

@@ -73,7 +73,7 @@ void at_th_entry(boost::basic_thread_pool& )
 
 int test_generic_executor_ref()
 {
-  // std::cout << BOOST_CONTEXTOF << std::endl;
+  std::cout << BOOST_CONTEXTOF << std::endl;
   {
     try
     {
@@ -83,8 +83,8 @@ int test_generic_executor_ref()
         {
           boost::future<int> t1 = boost::async(ea, &f1);
           boost::future<int> t2 = boost::async(ea, &f1);
-          // std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
-          // std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
+          std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
+          std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
         }
         submit_some(ea);
         {
@@ -93,41 +93,51 @@ int test_generic_executor_ref()
           boost::future<int> t2 = boost::async(ea3, &f1);
           //boost::future<int> t2 = boost::async(ea3, f2, 1); // todo this doesn't compiles yet on C++11
           //boost::future<int> t2 = boost::async(ea3, boost::bind(f2, 1)); // todo this doesn't compiles yet on C++98
-          // std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
-          // std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
+          std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
+          std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
         }
         submit_some(ea);
       }
-      // std::cout << BOOST_CONTEXTOF << std::endl;
+      std::cout << BOOST_CONTEXTOF << std::endl;
       {
         boost::loop_executor ea2;
         submit_some( ea2);
         ea2.run_queued_closures();
       }
 #if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-      // std::cout << BOOST_CONTEXTOF << std::endl;
+      std::cout << BOOST_CONTEXTOF << std::endl;
       {
         boost::basic_thread_pool ea1(4);
         boost::serial_executor ea2(ea1);
         submit_some(ea2);
       }
 #endif
-      // std::cout << BOOST_CONTEXTOF << std::endl;
+      std::cout << BOOST_CONTEXTOF << std::endl;
       {
         boost::inline_executor ea1;
         submit_some(ea1);
       }
-      // std::cout << BOOST_CONTEXTOF << std::endl;
+      std::cout << BOOST_CONTEXTOF << std::endl;
       {
         //boost::thread_executor ea1;
         //submit_some(ea1);
       }
-      // std::cout << BOOST_CONTEXTOF << std::endl;
+      std::cout << BOOST_CONTEXTOF << std::endl;
       {
         boost::basic_thread_pool  ea(4, at_th_entry);
         boost::future<int> t1 = boost::async(ea, &f1);
-        // std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
+        std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
       }
+      std::cout << BOOST_CONTEXTOF << std::endl;
+      {
+        boost::basic_thread_pool  ea(4, at_th_entry);
+        boost::async(ea, &f1);
+        std::cout << BOOST_CONTEXTOF << std::endl;
+      }
+      std::cout << BOOST_CONTEXTOF << std::endl;
+      boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
+      std::cout << BOOST_CONTEXTOF << std::endl;
+
     }
     catch (std::exception& ex)
     {

include/boost/thread/concurrent_queues/sync_queue.hpp

@@ -10,6 +10,7 @@
 // See http://www.boost.org/libs/thread for documentation.
 //
 //////////////////////////////////////////////////////////////////////////////
+#include <iostream>
 
 #include <boost/thread/detail/config.hpp>
 #include <boost/thread/concurrent_queues/detail/sync_queue_base.hpp>
@@ -150,13 +151,19 @@ namespace concurrent
   template <class ValueType, class Container>
   queue_op_status sync_queue<ValueType, Container>::wait_pull(ValueType& elem, unique_lock<mutex>& lk)
   {
+    //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     if (super::empty(lk))
     {
+      //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
       if (super::closed(lk)) return queue_op_status::closed;
     }
+    //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     bool has_been_closed = super::wait_until_not_empty_or_closed(lk);
+    //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     if (has_been_closed) return queue_op_status::closed;
+    //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     pull(elem, lk);
+    //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     return queue_op_status::success;
   }
 

include/boost/thread/detail/invoker.hpp

@@ -72,13 +72,21 @@ namespace boost
       BOOST_SYMBOL_VISIBLE
       invoker& operator=(BOOST_THREAD_RV_REF(invoker) f)
       {
-        f_ = boost::move(BOOST_THREAD_RV(f).f_);
+        if (this != &f)
+        {
+          f_ = boost::move(BOOST_THREAD_RV(f).f_);
+        }
+        return *this;
       }
 
       BOOST_SYMBOL_VISIBLE
       invoker& operator=( BOOST_THREAD_COPY_ASSIGN_REF(invoker) f)
       {
-        f_ = f.f_;
+        if (this != &f)
+        {
+          f_ = f.f_;
+        }
+        return *this;
       }
 
       result_type operator()()
@@ -91,7 +99,7 @@ namespace boost
       result_type
       execute(tuple_indices<Indices...>)
       {
-        return invoke(boost::move(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...);
+        return detail::invoke(boost::move(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...);
       }
     };
 
@@ -128,7 +136,7 @@ namespace boost
       result_type
       execute(tuple_indices<Indices...>)
       {
-        return invoke<R>(boost::move(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...);
+        return detail::invoke<R>(boost::move(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...);
       }
     };
   //BOOST_THREAD_DCL_MOVABLE_BEG(X) invoker<Fp> BOOST_THREAD_DCL_MOVABLE_END
@@ -182,7 +190,7 @@ namespace boost
       {} \
       \
       result_type operator()() { \
-        return invoke(boost::move(fp_) \
+        return detail::invoke(boost::move(fp_) \
             BOOST_PP_REPEAT(n, BOOST_THREAD_MOVE_DCL, ~) \
         ); \
       } \
@@ -307,7 +315,7 @@ namespace boost
 
       result_type operator()()
       {
-        return invoke(boost::move(fp_)
+        return detail::invoke(boost::move(fp_)
             , boost::move(v0_)
             , boost::move(v1_)
             , boost::move(v2_)
@@ -373,7 +381,7 @@ namespace boost
 
       result_type operator()()
       {
-        return invoke(boost::move(fp_)
+        return detail::invoke(boost::move(fp_)
             , boost::move(v0_)
             , boost::move(v1_)
             , boost::move(v2_)
@@ -434,7 +442,7 @@ namespace boost
 
       result_type operator()()
       {
-        return invoke(boost::move(fp_)
+        return detail::invoke(boost::move(fp_)
             , boost::move(v0_)
             , boost::move(v1_)
             , boost::move(v2_)
@@ -490,7 +498,7 @@ namespace boost
 
       result_type operator()()
       {
-        return invoke(boost::move(fp_)
+        return detail::invoke(boost::move(fp_)
             , boost::move(v0_)
             , boost::move(v1_)
             , boost::move(v2_)
@@ -541,7 +549,7 @@ namespace boost
 
       result_type operator()()
       {
-        return invoke(boost::move(fp_)
+        return detail::invoke(boost::move(fp_)
             , boost::move(v0_)
             , boost::move(v1_)
             , boost::move(v2_)
@@ -587,7 +595,7 @@ namespace boost
 
       result_type operator()()
       {
-        return invoke(boost::move(fp_)
+        return detail::invoke(boost::move(fp_)
             , boost::move(v0_)
             , boost::move(v1_)
             , boost::move(v2_)
@@ -628,7 +636,7 @@ namespace boost
 
       result_type operator()()
       {
-        return invoke(boost::move(fp_)
+        return detail::invoke(boost::move(fp_)
             , boost::move(v0_)
             , boost::move(v1_)
             , boost::move(v2_)
@@ -664,7 +672,7 @@ namespace boost
 
       result_type operator()()
       {
-        return invoke(boost::move(fp_)
+        return detail::invoke(boost::move(fp_)
             , boost::move(v0_)
             , boost::move(v1_)
         );
@@ -695,7 +703,7 @@ namespace boost
 
       result_type operator()()
       {
-        return invoke(boost::move(fp_)
+        return detail::invoke(boost::move(fp_)
             , boost::move(v0_)
         );
       }

include/boost/thread/detail/thread.hpp

@@ -72,7 +72,7 @@ namespace boost
           void run2(tuple_indices<Indices...>)
           {
 
-              invoke(std::move(std::get<0>(fp)), std::move(std::get<Indices>(fp))...);
+              detail::invoke(std::move(std::get<0>(fp)), std::move(std::get<Indices>(fp))...);
           }
           void run()
           {
@@ -354,6 +354,8 @@ namespace boost
 
 #if defined BOOST_THREAD_PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE
             if (joinable()) std::terminate();
+#else
+            detach();
 #endif
             thread_info=BOOST_THREAD_RV(other).thread_info;
             BOOST_THREAD_RV(other).thread_info.reset();

include/boost/thread/executors/basic_thread_pool.hpp

@@ -87,7 +87,9 @@ namespace executors
         {
           work task;
           queue_op_status st = work_queue.wait_pull(task);
-          if (st == queue_op_status::closed) return;
+          if (st == queue_op_status::closed) {
+            return;
+          }
           task();
         }
       }

include/boost/thread/executors/thread_executor.hpp

@@ -17,6 +17,7 @@
 #include <boost/thread/thread_only.hpp>
 #include <boost/thread/scoped_thread.hpp>
 #include <boost/thread/csbl/vector.hpp>
+#include <boost/thread/concurrent_queues/queue_op_status.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 

include/boost/thread/futures/launch.hpp

@@ -22,6 +22,8 @@ namespace boost
 #ifdef BOOST_THREAD_PROVIDES_EXECUTORS
       executor = 4,
 #endif
+      inherit = 8,
+      sync = 16,
       any = async | deferred
   }
   BOOST_SCOPED_ENUM_DECLARE_END(launch)

include/boost/thread/pthread/condition_variable.hpp

@@ -68,17 +68,14 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
             detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
+            pthread_mutex_t* the_mutex = &internal_mutex;
             guard.activate(m);
-            do {
-              res = pthread_cond_wait(&cond,&internal_mutex);
-            } while (res == EINTR);
 #else
-            //boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
             pthread_mutex_t* the_mutex = m.mutex()->native_handle();
+#endif
             do {
               res = pthread_cond_wait(&cond,the_mutex);
             } while (res == EINTR);
-#endif
         }
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
         this_thread::interruption_point();
@@ -99,18 +96,17 @@ namespace boost
             boost::throw_exception(condition_error(EPERM, "boost::condition_variable::do_wait_until() failed precondition mutex not owned"));
         }
 #endif
-        thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
         int cond_res;
         {
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+            thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
             detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
+            pthread_mutex_t* the_mutex = &internal_mutex;
             guard.activate(m);
-            cond_res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
 #else
-            //boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
             pthread_mutex_t* the_mutex = m.mutex()->native_handle();
-            cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout);
 #endif
+            cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout);
         }
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
         this_thread::interruption_point();
@@ -178,7 +174,7 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                 detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
 #else
-            boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
+                boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
 #endif
                 guard.activate(m);
                 res=pthread_cond_wait(&cond,&internal_mutex);
@@ -340,14 +336,15 @@ namespace boost
                                                    cv_status::timeout;
         }
 
+        template <class lock_type>
         inline cv_status wait_until(
-            unique_lock<mutex>& lk,
+            lock_type& lock,
             chrono::time_point<chrono::steady_clock, chrono::nanoseconds> tp)
         {
             using namespace chrono;
             nanoseconds d = tp.time_since_epoch();
             timespec ts = boost::detail::to_timespec(d);
-            if (do_wait_until(lk, ts)) return cv_status::no_timeout;
+            if (do_wait_until(lock, ts)) return cv_status::no_timeout;
             else return cv_status::timeout;
         }
 
@@ -395,7 +392,7 @@ namespace boost
     private: // used by boost::thread::try_join_until
 
         template <class lock_type>
-        inline bool do_wait_until(
+        bool do_wait_until(
           lock_type& m,
           struct timespec const &timeout)
         {
@@ -405,7 +402,7 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
               detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
 #else
-            boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
+              boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
 #endif
               guard.activate(m);
               res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
@@ -423,8 +420,6 @@ namespace boost
           }
           return true;
         }
-
-
     };
 
 }

include/boost/thread/scoped_thread.hpp

@@ -197,6 +197,9 @@ namespace boost
      */
     scoped_thread& operator=(BOOST_RV_REF(scoped_thread) x)
     {
+      CallableThread on_destructor;
+
+      on_destructor(t_);
       t_ = boost::move(BOOST_THREAD_RV(x).t_);
       return *this;
     }

include/boost/thread/v2/thread.hpp

@@ -91,7 +91,19 @@ namespace boost
         cv.wait_until(lk, t);
     }
 
-#if defined BOOST_THREAD_SLEEP_FOR_IS_STEADY && ! defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
+#if defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC && defined BOOST_CHRONO_HAS_CLOCK_STEADY
+    template <class Rep, class Period>
+    void sleep_for(const chrono::duration<Rep, Period>& d)
+    {
+      using namespace chrono;
+      if (d > duration<Rep, Period>::zero())
+      {
+        steady_clock::time_point c_timeout = steady_clock::now() + ceil<nanoseconds>(d);
+        sleep_until(c_timeout);
+      }
+    }
+
+#elif defined BOOST_THREAD_SLEEP_FOR_IS_STEADY
 
     template <class Rep, class Period>
     void sleep_for(const chrono::duration<Rep, Period>& d)
@@ -127,7 +139,8 @@ namespace boost
       using namespace chrono;
       if (d > duration<Rep, Period>::zero())
       {
-        steady_clock::time_point c_timeout = steady_clock::now() + ceil<nanoseconds>(d);
+        //system_clock::time_point c_timeout = time_point_cast<system_clock::duration>(system_clock::now() + ceil<nanoseconds>(d));
+        system_clock::time_point c_timeout = system_clock::now() + ceil<system_clock::duration>(d);
         sleep_until(c_timeout);
       }
     }

include/boost/thread/win32/thread_primitives.hpp

@@ -156,7 +156,7 @@ namespace boost
             {
                 struct _SECURITY_ATTRIBUTES;
 # ifdef BOOST_NO_ANSI_APIS
-# if BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
+# if defined(BOOST_USE_WINAPI_VERSION) && ( BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA )
                 __declspec(dllimport) void* __stdcall CreateMutexW(_SECURITY_ATTRIBUTES*,int,wchar_t const*);
                 __declspec(dllimport) void* __stdcall CreateSemaphoreW(_SECURITY_ATTRIBUTES*,long,long,wchar_t const*);
                 __declspec(dllimport) void* __stdcall CreateEventW(_SECURITY_ATTRIBUTES*,int,int,wchar_t const*);
@@ -339,7 +339,7 @@ namespace boost
             {
 #if !defined(BOOST_NO_ANSI_APIS)
                 handle const res = win32::CreateEventA(0, type, state, mutex_name);
-#elif BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
+#elif defined(BOOST_USE_WINAPI_VERSION) && ( BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA )
                 handle const res = win32::CreateEventW(0, type, state, mutex_name);
 #else
                 handle const res = win32::CreateEventExW(
@@ -366,7 +366,7 @@ namespace boost
 #if !defined(BOOST_NO_ANSI_APIS)
                 handle const res=win32::CreateSemaphoreA(0,initial_count,max_count,0);
 #else
-#if BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
+#if defined(BOOST_USE_WINAPI_VERSION) && ( BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA )
                 handle const res=win32::CreateSemaphoreEx(0,initial_count,max_count,0,0);
 #else
                 handle const res=win32::CreateSemaphoreExW(0,initial_count,max_count,0,0,semaphore_all_access);

src/pthread/once.cpp

@@ -42,6 +42,7 @@ namespace boost
                 }
             }
 
+#if defined BOOST_THREAD_PATCH
             const pthread_once_t pthread_once_init_value=PTHREAD_ONCE_INIT;
             struct BOOST_THREAD_DECL delete_epoch_tss_key_on_dlclose_t
             {
@@ -52,11 +53,15 @@ namespace boost
                 {
                     if(memcmp(&epoch_tss_key_flag, &pthread_once_init_value, sizeof(pthread_once_t)))
                     {
+                        void* data = (void*)pthread_getspecific(epoch_tss_key);
+                        if (data)
+                            delete_epoch_tss_data(data);
                         pthread_key_delete(epoch_tss_key);
                     }
                 }
             };
             delete_epoch_tss_key_on_dlclose_t delete_epoch_tss_key_on_dlclose;
+#endif
         }
 
         uintmax_atomic_t& get_once_per_thread_epoch()

src/pthread/thread.cpp

@@ -80,8 +80,8 @@ namespace boost
             {
                 static void tls_destructor(void* data)
                 {
-                    boost::detail::thread_data_base* thread_info=static_cast<boost::detail::thread_data_base*>(data);
-                    //boost::detail::thread_data_ptr thread_info = static_cast<boost::detail::thread_data_base*>(data)->shared_from_this();
+                    //boost::detail::thread_data_base* thread_info=static_cast<boost::detail::thread_data_base*>(data);
+                    boost::detail::thread_data_ptr thread_info = static_cast<boost::detail::thread_data_base*>(data)->shared_from_this();
 
                     if(thread_info)
                     {
@@ -110,14 +110,12 @@ namespace boost
                                 thread_info->tss_data.erase(current);
                             }
                         }
-                        if (thread_info) // fixme: should we test this?
-                        {
-                          thread_info->self.reset();
-                        }
+                        thread_info->self.reset();
                     }
                 }
             }
 
+#if defined BOOST_THREAD_PATCH
             struct  delete_current_thread_tls_key_on_dlclose_t
             {
                 delete_current_thread_tls_key_on_dlclose_t()
@@ -128,12 +126,15 @@ namespace boost
                     const boost::once_flag uninitialized = BOOST_ONCE_INIT;
                     if (memcmp(&current_thread_tls_init_flag, &uninitialized, sizeof(boost::once_flag)))
                     {
+                      void* data = pthread_getspecific(current_thread_tls_key);
+                      if (data)
+                          tls_destructor(data);
                         pthread_key_delete(current_thread_tls_key);
                     }
                 }
             };
             delete_current_thread_tls_key_on_dlclose_t delete_current_thread_tls_key_on_dlclose;
-
+#endif
             void create_current_thread_tls_key()
             {
                 BOOST_VERIFY(!pthread_key_create(&current_thread_tls_key,&tls_destructor));

src/win32/thread.cpp

@@ -24,6 +24,7 @@
 #include <boost/cstdint.hpp>
 #if defined BOOST_THREAD_USES_DATETIME
 #include <boost/date_time/posix_time/conversion.hpp>
+#include <boost/thread/thread_time.hpp>
 #endif
 #include <boost/thread/csbl/memory/unique_ptr.hpp>
 #include <memory>
@@ -467,7 +468,7 @@ namespace boost
 #if defined BOOST_THREAD_USES_DATETIME
     bool thread::timed_join(boost::system_time const& wait_until)
     {
-      return do_try_join_until(get_milliseconds_until(wait_until));
+      return do_try_join_until(boost::detail::get_milliseconds_until(wait_until));
     }
 #endif
     bool thread::do_try_join_until_noexcept(uintmax_t milli, bool& res)
@@ -529,7 +530,7 @@ namespace boost
     {
       // a bit too strict: Windows XP with SP3 would be sufficient
 #if BOOST_PLAT_WINDOWS_RUNTIME                                    \
-    || ( BOOST_USE_WINAPI_VERSION <= BOOST_WINAPI_VERSION_WINXP ) \
+    || ( defined(BOOST_USE_WINAPI_VERSION) && ( BOOST_USE_WINAPI_VERSION <= BOOST_WINAPI_VERSION_WINXP ) ) \
     || ( ( defined(__MINGW32__) && !defined(__MINGW64__) ) && _WIN32_WINNT < 0x0600)
         return 0;
 #else

test/Jamfile.v2

@@ -31,7 +31,8 @@ project
         <toolset>gcc:<cxxflags>-Wno-long-long
         #<toolset>gcc:<cxxflags>-ansi
         #<toolset>gcc:<cxxflags>-fpermissive
-        <toolset>gcc:<cxxflags>-Wno-variadic-macros
+        <toolset>gcc-4:<cxxflags>-Wno-variadic-macros
+        <toolset>gcc-5:<cxxflags>-Wno-variadic-macros
         #<toolset>gcc:<cxxflags>-Wunused-local-typedefs
         <toolset>gcc:<cxxflags>-Wunused-function
         <toolset>gcc:<cxxflags>-Wno-unused-parameter
@@ -811,7 +812,7 @@ rule thread-compile ( sources : reqs * : name )
           [ thread-run2 ../example/executor.cpp : ex_executor ]
           [ thread-run2 ../example/generic_executor_ref.cpp : ex_generic_executor_ref ]
           [ thread-run2 ../example/serial_executor.cpp : ex_serial_executor ]
-          [ thread-run2 ../example/serial_executor_cont.cpp : ex_serial_executor_cont ]
+          #[ thread-run2 ../example/serial_executor_cont.cpp : ex_serial_executor_cont ]
           [ thread-run2 ../example/future_when_all.cpp : ex_future_when_all ]
           [ thread-run2 ../example/parallel_accumulate.cpp : ex_parallel_accumulate ]
           [ thread-run2 ../example/parallel_quick_sort.cpp : ex_parallel_quick_sort ]
@@ -958,9 +959,13 @@ rule thread-compile ( sources : reqs * : name )
     explicit ts_ ;
     test-suite ts_
     :
+          #[ thread-run test_11256.cpp ] 
           #[ thread-run test_11256.cpp ]
           #[ thread-run test_11499.cpp ]
-          [ thread-run test_11611.cpp ]
+          #[ thread-run test_11611.cpp ]
+          #[ thread-run test_11818.cpp ]
+          [ thread-run test_11796.cpp ]
+          
     ;
 
 

test/test_10964.cpp

@@ -38,6 +38,27 @@ struct TestCallback
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     //boost::future<void> ff = future.get();
 
+    return boost::make_ready_future();
+  }
+  result_type operator()(boost::shared_future<void> future) const
+  {
+    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+    assert(future.is_ready());
+    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+    future.wait();
+    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+    return boost::make_ready_future();
+  }
+
+  result_type operator()(boost::shared_future<boost::future<void> > future) const
+  {
+    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+    assert(future.is_ready());
+    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+    assert(future.get().is_ready());
+    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+    //boost::future<void> ff = future.get();
+
     return boost::make_ready_future();
   }
 };
@@ -75,11 +96,17 @@ int main()
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
   for (int i=0; i< number_of_tests; i++)
   {
-    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     auto f1 = boost::make_ready_future().then(TestCallback());
     BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
     boost::future<void> f2 = f1.get();
-    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+  }
+  std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+  {
+    auto f1 = boost::make_ready_future().then(TestCallback());
+    BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
+    auto f3 = f1.then(TestCallback());
+    BOOST_STATIC_ASSERT(std::is_same<decltype(f3), boost::future<boost::future<void> > >::value);
+    f3.wait();
   }
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
   for (int i=0; i< number_of_tests; i++)
@@ -114,8 +141,6 @@ int main()
     BOOST_STATIC_ASSERT(std::is_same<decltype(f3), boost::future<boost::future<void> > >::value);
     f3.wait();
   }
-
-
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
   for (int i=0; i< number_of_tests; i++)
   {
@@ -126,10 +151,12 @@ int main()
     BOOST_STATIC_ASSERT(std::is_same<decltype(f3), boost::future<boost::future<void> > >::value);
     f3.wait();
   }
+#if 1
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+  // fixme
   for (int i=0; i< number_of_tests; i++)
   {
-    boost::basic_thread_pool executor(1);
+    boost::basic_thread_pool executor(2);
 
     auto f1 = boost::make_ready_future().then(executor, TestCallback());
     BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
@@ -142,6 +169,7 @@ int main()
     BOOST_STATIC_ASSERT(std::is_same<decltype(f3), boost::future<boost::future<void> > >::value);
     f3.wait();
   }
+#endif
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
   for (int i=0; i< number_of_tests; i++)
   {

test/test_11796.cpp

@@ -0,0 +1,33 @@
+// Copyright (C) 2015 Vicente Botet
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread.hpp>
+#include <boost/chrono.hpp>
+#include <iostream>
+
+boost::thread th;
+int main()
+{
+
+  for (auto ti = 0; ti < 1000; ti++)
+  {
+    th  = boost::thread([ti]()
+      {
+        boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
+        std::cout << ti << std::endl;
+      });
+  }
+  std::string st;
+
+  std::cin >> st;
+
+//  for (int i = 0; i < 10; ++i) {
+//    std::cout << "." << i << std::endl;
+//    boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
+//  }
+  th.join();
+  return 0;
+}
+

test/test_11818.cpp

@@ -0,0 +1,64 @@
+// Copyright (C) 2014 Vicente Botet
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#define BOOST_THREAD_VERSION 4
+#include <boost/config.hpp>
+#if ! defined  BOOST_NO_CXX11_DECLTYPE
+#define BOOST_RESULT_OF_USE_DECLTYPE
+#endif
+
+#include <boost/thread/future.hpp>
+#include <boost/thread/thread.hpp>
+#include <thread>
+
+int main()
+{
+
+  {
+    boost::promise<int> promise;
+    boost::future<int> future = promise.get_future();
+
+    boost::future<int> result =
+    future.then
+    (
+        boost::launch::deferred,
+        [](boost::future<int> && f)
+        {
+            std::cout << std::this_thread::get_id() << ": callback" << std::endl;
+            std::cout << "The value is: " << f.get() << std::endl;
+            return f.get();
+        }
+    );
+
+    // We could not reach here.
+    std::cout << std::this_thread::get_id() << ": function" << std::endl;
+
+    promise.set_value(0);
+  }
+
+  {
+    boost::promise<int> promise;
+    boost::shared_future<int> future = promise.get_future().share();
+
+    boost::future<int> result =
+    future.then
+    (
+        boost::launch::deferred,
+        [](boost::shared_future<int> && f)
+        {
+            std::cout << std::this_thread::get_id() << ": callback" << std::endl;
+            std::cout << "The value is: " << f.get() << std::endl;
+            return f.get();
+        }
+    );
+
+    // We could not reach here.
+    std::cout << std::this_thread::get_id() << ": function" << std::endl;
+
+    promise.set_value(0);
+  }
+
+  return 0;
+}

test/test_2309.cpp

@@ -5,12 +5,13 @@
 
 #define BOOST_THREAD_VERSION 2
 #define BOOST_THREAD_PROVIDES_INTERRUPTIONS
-#define BOOST_TEST_MODULE Boost.Threads: 2309
-#include <boost/test/unit_test.hpp>
+//#define BOOST_TEST_MODULE Boost.Threads: 2309
+//#include <boost/test/unit_test.hpp>
 
 #include <iostream>
 
 #include <boost/thread.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
   using namespace std;
 
@@ -40,7 +41,7 @@
      }
   }
 
-  BOOST_AUTO_TEST_CASE(test)
+  void ticket_2309_test()
   {
     try
     {
@@ -57,9 +58,13 @@
     }
     catch (...)
     {
-      BOOST_CHECK(false && "exception raised");
+      BOOST_TEST(false && "exception raised");
     }
   }
 
+  int main()
+  {
 
+    ticket_2309_test();
+  }
 

test/threads/thread/constr/FArgs_pass.cpp

@@ -33,7 +33,7 @@ inline void* operator new(std::size_t s)
 void* operator new(std::size_t s) throw (std::bad_alloc)
 #endif
 {
-  std::cout << __FILE__ << ":" << __LINE__ << std::endl;
+  //std::cout << __FILE__ << ":" << __LINE__ << std::endl;
   if (throw_one == 0) throw std::bad_alloc();
   --throw_one;
   return std::malloc(s);
@@ -45,7 +45,7 @@ inline void operator delete(void* p)
 inline void operator delete(void* p) throw ()
 #endif
 {
-  std::cout << __FILE__ << ":" << __LINE__ << std::endl;
+  //std::cout << __FILE__ << ":" << __LINE__ << std::endl;
   std::free(p);
 }
 

test/threads/thread/constr/F_pass.cpp

@@ -33,7 +33,7 @@ void* operator new(std::size_t s)
 void* operator new(std::size_t s) throw (std::bad_alloc)
 #endif
 {
-  std::cout << __FILE__ << ":" << __LINE__ << std::endl;
+  //std::cout << __FILE__ << ":" << __LINE__ << std::endl;
   if (throw_one == 0) throw std::bad_alloc();
   --throw_one;
   return std::malloc(s);
@@ -45,7 +45,7 @@ void operator delete(void* p)
 void operator delete(void* p) throw ()
 #endif
 {
-  std::cout << __FILE__ << ":" << __LINE__ << std::endl;
+  //std::cout << __FILE__ << ":" << __LINE__ << std::endl;
   std::free(p);
 }