std::promise<R>::set_value_at_thread_exit

Main template
void set_value_at_thread_exit( const R& value );	(1)	(since C++11)
void set_value_at_thread_exit( R&& value );	(2)	(since C++11)
std::promise<R&> specializations
void set_value_at_thread_exit( R& value );	(3)	(since C++11)
std::promise<void> specialization
void set_value_at_thread_exit();	(4)	(since C++11)

Stores the value into the shared state without making the state ready immediately. The state is made ready when the current thread exits, after all variables with thread-local storage duration have been destroyed.

The operation behaves as though set_value, set_exception, set_value_at_thread_exit, and set_exception_at_thread_exit acquire a single mutex associated with the promise object while updating the promise object.

Calls to this function do not introduce data races with calls to get_future (therefore they need not synchronize with each other).

Parameters

value

-

value to store in the shared state

Return value

(none)

Exceptions

std::future_error on the following conditions:

*this has no shared state. The error code is set to no_state.
The shared state already stores a value or exception. The error code is set to promise_already_satisfied.

Additionally:

1) Any exception thrown by the constructor selected to copy an object of type R.

2) Any exception thrown by the constructor selected to move an object of type R.

Example

Run this code

#include <future>
#include <iostream>
#include <thread>
 
int main()
{
    using namespace std::chrono_literals;
    std::promise<int> p;
    std::future<int> f = p.get_future();
    std::thread([&p]
    {
        std::this_thread::sleep_for(1s);
        p.set_value_at_thread_exit(9);
    }).detach();
 
    std::cout << "Waiting... " << std::flush;
    f.wait();
    std::cout << "Done!\nResult is: " << f.get() << '\n';
}

Output:

Waiting... Done!
Result is: 9

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
LWG 2098	C++11	it was unclear which exceptions are required to be thrown	made clear

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

Member functions
promise::promise
promise::~promise
promise::operator=
promise::swap
Getting the result
promise::get_future
Setting the result
promise::set_value
promise::set_value_at_thread_exit
promise::set_exception
promise::set_exception_at_thread_exit
Non-member Functions
swap(std::promise)
Helper Classes
uses_allocator<std::promise>