std::execution

Sender — объект, описывающий асинхронную операцию (например, "прочитать файл" или "выполнить работу на планировщике"), но не выполняющий её при создании. Receiver — обработчик завершения с тремя каналами: set_value (успех), set_error (ошибка) и set_stopped (отмена). Соединение sender и receiver через connect() даёт "operation state" — объект, хранящий всё состояние операции; вызов start() на нём запускает выполнение. Библиотека предоставляет алгебру композиции senders — then, let_value, when_all и другие — так что сложные асинхронные графы строятся из простых кусочков декларативно.A sender is an object describing an asynchronous operation (e.g. "read a file" or "run work on a scheduler") without executing it at construction time. A receiver is the completion handler with three channels: set_value (success), set_error (failure), and set_stopped (cancellation). Connecting a sender and a receiver via connect() produces an "operation state" — an object holding all the operation's state; calling start() on it begins execution. The library provides an algebra for composing senders — then, let_value, when_all, and others — so complex asynchronous graphs are built declaratively out of small pieces.

// std::future — одноразовый, не композируется, часто блокирующий .get()// std::future — one-shot, doesn't compose, often a blocking .get()
std::future<int> f = std::async([]{ return compute(); });
int result = f.get();  // блокирует поток; нельзя навесить продолжение без ручного колбэка// blocks the thread; no way to attach a continuation without a manual callback

namespace ex = std::execution;

auto work = ex::just(42)
             | ex::then([](int x) { return x * 2; });

auto result = std::this_thread::sync_wait(work);  // запускает и синхронно ждёт результат// starts it and synchronously waits for the result

До P2300 в C++ не было единого словаря для асинхронности — каждая часть экосистемы говорила на своём диалекте:Before P2300, C++ had no single vocabulary for asynchrony — every part of the ecosystem spoke its own dialect:

Базовый sender ex::just(value) — это sender, который сразу и без ошибок завершается со значением value. Оператор | (аналогично ranges) навешивает на sender адаптер вроде then, порождая новый sender — построение цепочки не выполняет никакой работы, это просто описание графа вычислений. Выполнение начинается только при вызове connect() + start(), что обычно скрыто внутри вспомогательной функции вроде std::this_thread::sync_wait.The basic sender ex::just(value) is a sender that completes immediately and without error with the value value. The | operator (analogous to ranges) attaches an adapter like then to a sender, producing a new sender — building the chain performs no work at all, it is purely a description of the computation graph. Execution begins only when connect() + start() is called, which is usually hidden inside a helper such as std::this_thread::sync_wait.

namespace ex = std::execution;

// just(42) ничего не выполняет сам по себе — это лишь описание "значение 42 готово"// just(42) executes nothing on its own — it merely describes "the value 42 is ready"
auto sender = ex::just(42) | ex::then([](int x) { return x * 2; });

// ничего не произошло до этой строки: sync_wait соединяет с receiver и запускает// nothing has happened until this line: sync_wait connects a receiver and starts it
auto [result] = std::this_thread::sync_wait(sender).value();  // result == 84// result == 84

Планировщик (scheduler) — объект, у которого есть метод schedule(), возвращающий sender, завершающийся на нужном исполнителе (thread pool, GPU-очередь и т.д.). Пристыковав к нему then(...), вы описываете "выполнить эту работу именно там".A scheduler is an object with a schedule() method that returns a sender which completes on the desired execution context (a thread pool, a GPU queue, etc.). Attaching then(...) to it describes "run this work specifically there".

thread_pool pool(4);
auto sched = pool.get_scheduler();

auto work = sched.schedule()
           | ex::then([] { return heavy_cpu_task(); });  // выполнится на потоке пула// runs on a pool thread

when_all объединяет несколько senders в один, который завершается, когда завершились все входные — это структурированный параллелизм: оба под-sender стартуют независимо, но результат доступен только когда оба готовы.when_all combines several senders into one that completes once all of the inputs have completed — this is structured concurrency: both sub-senders start independently, but the result is only available once both are ready.

auto combined = ex::when_all(fetch_user_sender(), fetch_orders_sender())
                | ex::then([](User u, Orders o) { return merge(u, o); });

• WG21 P2300 — std::execution
• cppreference — Execution library