The class templatestd::barrier provides a thread-coordination mechanism that blocks a group of threads of known size until all threads in that group have reached the barrier. Unlikestd::latch, barriers are reusable: once a group of arriving threads are unblocked, the barrier can be reused. Unlikestd::latch, barriers execute a possibly empty callable before unblocking threads.

A barrier object's lifetime consists of one or more phases. Each phase defines aphase synchronization point where waiting threads block. Threads can arrive at the barrier, but defer waiting on thephase synchronization point by callingarrive. Such threads can later block on thephase synchronization point by callingwait.

A barrierphase consists of the following steps:

1. Theexpected count is decremented by each call toarrive orarrive_and_drop.
2. When the expected count reaches zero, thephase completion step is run, meaning that thecompletion is invoked, and all threads blocked on the phase synchronization point are unblocked. The end of the completion stepstrongly happens-before all calls that were unblocked by the completion step return.
   Exactly once after the expected count reaches zero, a thread executes the completion step during its call toarrive,arrive_and_drop, orwait, except that it is implementation-defined whether the step executes if no thread callswait.
3. When the completion step finishes, the expected count is reset to the value specified at construction less the number of calls toarrive_and_drop since, and the nextbarrier phase begins.

Concurrent invocations of the member functions ofbarrier, except for the destructor, do not introduce data races.

[edit]Template parameters

The default template argument ofCompletionFunction is an unspecified function object type that additionally meets the requirements ofDefaultConstructible. Calling an lvalue of it with no arguments has no effects.

[edit]Member types

[edit]Data members

[edit]Member functions

[edit]Notes

[edit]Example

#include <barrier>#include <iostream>#include <string>#include <syncstream>#include <thread>#include <vector> int main(){constauto workers={"Anil","Busara","Carl"}; auto on_completion=[]()noexcept{// locking not needed herestaticauto phase="... done\n""Cleaning up...\n";std::cout<< phase;        phase="... done\n";};     std::barrier sync_point(std::ssize(workers), on_completion); auto work=[&](std::string name){std::string product="  "+ name+" worked\n";std::osyncstream(std::cout)<< product;// ok, op<< call is atomic        sync_point.arrive_and_wait();         product="  "+ name+" cleaned\n";std::osyncstream(std::cout)<< product;        sync_point.arrive_and_wait();}; std::cout<<"Starting...\n";std::vector<std::jthread> threads;    threads.reserve(std::size(workers));for(autoconst& worker: workers)        threads.emplace_back(work, worker);}

Starting...  Anil worked  Carl worked  Busara worked... doneCleaning up...  Busara cleaned  Carl cleaned  Anil cleaned... done

[edit]Defect reports

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

[edit]See also

• In other languages

• Español
• 日本語
• Русский
• 中文