std::experimental::barrier

From cppreference.com
Defined in header <experimental/barrier>
class barrier;
(concurrency TS)

The class std::experimental::barrier provides a thread-coordination mechanism that allows a set of participating threads to block until an operation is completed. Unlike std::experimental::latch, barriers are reusable; once the participating threads are released from a barrier's synchronization point, they can reuse the same barrier.

A barrier has a completion phase, which is executed by one of the participating threads once all threads in the set of participating threads arrive at the synchronization point. The arrive_and_wait and arrive_and_drop calls synchronize with the start of the completion phase; the end of the completion phase synchronizes with the returns from all calls blocked by its completion.

For std::experimental::barrier, the completion phase is empty. std::experimental::flex_barrier allows the user to control the completion phase with a function object.

The set of participating threads for a barrier constructed for num_threads threads is the first num_threads threads to arrive at its synchronization point after construction. The same set of threads (except for threads that called arrive_and_drop()) must arrive at the barrier each cycle.

Member functions

constructs a barrier
(public member function)
destroys the barrier
(public member function)
operator=
[deleted]
not copy-assignable
(public member function)
arrive at the synchronization point and block
(public member function)
arrive at the synchronization point and remove the current thread from the set of participating threads
(public member function)