std::notify_all_at_thread_exit
| Defined in header <condition_variable>
|
||
| void notify_all_at_thread_exit( std::condition_variable& cond, std::unique_lock<std::mutex> lk ); |
(since C++11) | |
notify_all_at_thread_exit provides a mechanism to determine when all thread_local objects in a detached thread have been destructed:
- Ownership of the previously acquired lock
lkis transferred to internal storage.
- The execution environment is modified such that when the current thread exits, after the destructors for all objects with thread local storage duration are called, the condition variable
condis notified as if by:
lk.unlock();
cond.notify_all();
An equivalent effect may be achieved with the facilities provided by std::promise or std::packaged_task.
Contents |
Notes
Calling this function if lock.mutex() is not locked by the current thread is undefined behavior.
Calling this function if lock.mutex() is not the same mutex as the one used by all other threads that are currently waiting on the same condition variable is undefined behavior.
The supplied lock lk is held until the thread exits. Once this function has been called, no more threads may acquire the same lock in order to wait on cond. If some thread is waiting on this condition variable, it should not attempt to release and reacquire the lock when it wakes up spuriously.
In typical use cases, this function is the last thing called by a detached thread.
Parameters
| cond | - | the condition variable to notify at thread exit |
| lk | - | the lock associated with the condition variable cond
|
Return value
(none)
Example
Code fragment illustrating the intended use for notify_all_at_thread_exit
#include <mutex> #include <thread> std::mutex m; std::condition_variable cv; bool ready = false; ComplexType result; void thread_func() { std::unique_lock<std::mutex> lk(m); result = function_that_uses_thread_locals(); ready = true; std::notify_all_at_thread_exit(cv, std::move(lk)); } // destroy thread_locals, notify cv, unlock mutex int main() { std::thread t(thread_func); t.detach(); // do other work std::unique_lock<std::mutex> lk(m); while(!ready) { cv.wait(lk); // wait for the detached thread } process(result); // result is ready and thread_locals are destructed }
