std::barrier / std::latch / std::counting_semaphore

std::latch (<latch>) — одноразовый счётчик обратного отсчёта: создаётся с числом N, каждый поток вызывает count_down() по достижении точки, а wait() блокирует, пока счётчик не дойдёт до нуля. После срабатывания latch не переиспользуется. std::barrier (<barrier>) решает ту же задачу "рандеву N потоков", но циклически: после того как все N потоков вызвали arrive_and_wait(), барьер автоматически сбрасывается и готов к следующей фазе — плюс опциональный completion callback, вызываемый одним из потоков на каждой фазе. std::counting_semaphore<N>/std::binary_semaphore (<semaphore>) — классический семафор: acquire()/release(), ограничение на N одновременных "держателей" ресурса.std::latch (<latch>) is a one-shot countdown counter: created with a count N, every thread calls count_down() on reaching the point, and wait() blocks until the counter reaches zero. Once it fires, a latch isn't reused. std::barrier (<barrier>) solves the same "N threads rendezvous" problem, but cyclically: once all N threads have called arrive_and_wait(), the barrier automatically resets and is ready for the next phase — plus an optional completion callback, invoked by one of the threads on each phase. std::counting_semaphore<N>/std::binary_semaphore (<semaphore>) is a classic semaphore: acquire()/release(), capping how many "holders" of a resource can exist at once.

Происхождение: latch и barrier родом из Concurrency TS — экспериментального документа комитета, где они обкатывались до включения в основной стандарт (см. cpp_ts_extensions.md для полного разбора TS-механизма и того, что из Concurrency TS дошло до C++20, а что нет). Семафора в самом TS не было в этом виде — он стандартизирован в C++20 напрямую, закрывая давний пробел: до этого в стандартной библиотеке C++ не было счётного семафора вовсе.Origin: latch and barrier come from the Concurrency TS — an experimental committee document where they were trialed before making it into the core standard (see cpp_ts_extensions.md for the full breakdown of the TS mechanism, and what from the Concurrency TS did and didn't make it into C++20). The semaphore wasn't in the TS in this form — it was standardized directly in C++20, closing a long-standing gap: before this, the C++ standard library had no counting semaphore at all.

std::mutex m;
std::condition_variable cv;
int arrived = 0;
const int N = 4;

void rendezvous() {
    std::unique_lock<std::mutex> lk(m);
    ++arrived;
    if (arrived == N) cv.notify_all();
    else cv.wait(lk, [&] { return arrived == N; });
    // вручную, легко ошибиться со сбросом счётчика для след. фазы// hand-rolled, easy to get the counter reset wrong for the next phase
}

std::barrier sync_point(4);   // 4 потока// 4 threads

void rendezvous() {
    sync_point.arrive_and_wait();
    // готово к следующей фазе автоматически// automatically ready for the next phase
}

#include <latch>
#include <barrier>
#include <semaphore>

// latch — одноразово: N потоков должны финишировать перед общим стартом// latch — one-shot: N threads must finish before a shared start
std::latch workers_ready(4);
// каждый воркер: workers_ready.count_down();// each worker: workers_ready.count_down();
// главный поток: workers_ready.wait();  // once — второй раз так не заведётся// main thread: workers_ready.wait();  // once — won't fire a second time

// barrier — переиспользуемо: цикл из фаз вычисления// barrier — reusable: a loop of computation phases
std::barrier sync_phase(4, [] { /* completion callback — один поток, один раз за фазу *//* completion callback — one thread, once per phase */ });
for (int phase = 0; phase < 10; ++phase) {
    // ... вычисления фазы ...// ... phase computation ...
    sync_phase.arrive_and_wait();   // готов к следующей фазе после этого вызова// ready for the next phase after this call
}

// semaphore — ограничить доступ к ресурсу N держателями одновременно// semaphore — cap concurrent access to a resource at N holders
std::counting_semaphore<3> pool_slots(3);   // не более 3 одновременно// no more than 3 at once
pool_slots.acquire();   // заблокируется, если все 3 слота заняты// blocks if all 3 slots are taken
// ... работа с ограниченным ресурсом ...// ... work using the limited resource ...
pool_slots.release();

Все три построены поверх того же фундамента, что mutex/condition_variable/atomic (futex на Linux в неконтендед-случае, разбор — в cpp_concurrency.md), но с более узким и явно поименованным контрактом — компилятору/читателю кода не нужно распознавать паттерн "condition_variable + счётчик" по смыслу, имя типа уже говорит, что это за паттерн.All three are built on the same foundation as mutex/condition_variable/atomic (a futex on Linux in the uncontended case, covered in cpp_concurrency.md), but with a narrower, explicitly named contract — the compiler or the reader of the code doesn't need to recognize the "condition_variable + counter" pattern by inference; the type name already states what pattern this is.

std::counting_semaphore<N> закрывает ещё одну частую задачу — ограничение параллелизма доступа к ограниченному ресурсу (пул соединений, лимит одновременных worker-задач), классический паттерн "resource pool" через семафор:std::counting_semaphore<N> also covers another common problem — limiting concurrent access to a bounded resource (a connection pool, a cap on simultaneous worker tasks), the classic "resource pool" pattern implemented via a semaphore:

#include <semaphore>

class ConnectionPool {
    std::counting_semaphore<8> slots_{8};   // не более 8 одновременных соединений// no more than 8 concurrent connections
    std::vector<Connection> connections_;
public:
    Connection& acquire() {
        slots_.acquire();   // заблокирует вызывающий поток, если все 8 заняты// blocks the calling thread if all 8 are taken
        return pick_free_connection();
    }
    void release(Connection& c) {
        mark_free(c);
        slots_.release();   // освобождает слот, будит один из ожидающих acquire()// frees a slot, wakes one of the threads waiting on acquire()
    }
};   // девятый одновременный запрос просто ждёт на acquire(), пока кто-то не освободит слот// a ninth concurrent request simply waits on acquire() until someone frees a slot

• cppreference — std::latch
• cppreference — std::barrier
• cppreference — std::counting_semaphore
• WG21 P1135 — The C++20 Synchronization Library