std::future / std::promise / std::async

std::promise<T> и std::future<T> — парный одноразовый канал передачи результата (или исключения) между потоками: promise.set_value() на стороне производителя делает результат доступным, future.get() на стороне потребителя блокируется до появления результата и возвращает его ровно один раз. std::async — функция, которая запускает вызываемый объект (возможно, в отдельном потоке) и сразу возвращает future на его будущий результат.std::promise<T> and std::future<T> form a paired, single-use channel for passing a result (or an exception) between threads: promise.set_value() on the producer side makes the result available, future.get() on the consumer side blocks until the result appears and returns it exactly once. std::async is a function that launches a callable (possibly on a separate thread) and immediately returns a future for its eventual result.

int result; bool done = false;
std::mutex m; std::condition_variable cv;
std::thread t([&]{
    result = compute();
    { std::lock_guard<std::mutex> lk(m); done = true; }
    cv.notify_one();
});
std::unique_lock<std::mutex> lk(m);
cv.wait(lk, [&]{ return done; });
t.join();

std::future<int> fut = std::async(std::launch::async, compute);
int result = fut.get();   // блокируется до готовности,// blocks until ready,
                            // синхронизация — внутри future// synchronization lives inside future

future/promise/async закрывают частый шаблонный код поверх thread + mutex + condition_variable:future/promise/async eliminate a common piece of boilerplate built on top of thread + mutex + condition_variable:

Внутри promise/future лежит общее разделяемое состояние (shared state), доступ к которому синхронизирован — концептуально тем же mutex + condition_variable, которые разобраны в mutex-condvar.html и подробно — в cpp_concurrency.md. std::future/std::promise можно рассматривать как готовую, стандартизованную реализацию именно того паттерна «одноразовая передача результата», который иначе пришлось бы писать вручную.Underneath, promise/future share a common shared state, access to which is synchronized — conceptually the same mutex + condition_variable covered in mutex-condvar.html and in detail in cpp_concurrency.md. std::future/std::promise can be seen as a ready-made, standardized implementation of exactly that "single-use result handoff" pattern you'd otherwise have to write by hand.

#include <future>

int compute(int x) { return x * x; }

int main() {
    // async — самый простой способ получить future:// async — the simplest way to get a future:
    std::future<int> fut = std::async(std::launch::async, compute, 6);
    // ... другая работа, пока compute считается в фоне ...// ... other work while compute runs in the background ...
    int result = fut.get();     // блокируется, если ещё не готово; 36// blocks if not ready yet; 36

    // promise — явный контроль над тем, кто и когда пишет результат:// promise — explicit control over who writes the result and when:
    std::promise<int> prom;
    std::future<int> fut2 = prom.get_future();
    std::thread t([&prom] { prom.set_value(compute(7)); });
    std::cout << fut2.get();    // 49
    t.join();
}

future.get() можно вызвать только один раз — после этого future переходит в невалидное состояние; для повторного чтения результата несколькими потребителями в C++11 нет прямого решения (std::shared_future появляется тоже в C++11 именно для этого случая — множественные получатели одного результата).future.get() can only be called once — after that the future moves into an invalid state; C++11 has no direct solution for reading the result repeatedly from multiple consumers (std::shared_future, also introduced in C++11, exists precisely for that case — multiple recipients of the same result).

• cppreference — std::future
• cppreference — std::async
• WG21 N2497 — Multi-threading Library for Standard C++