java provides the synchronized keyword for synchronizing thread access to critical
sections. Because it can be difficult to correctly write synchronized code that’s based on
synchronized, high-level synchronizers are included in the concurrency utilities.
A countdown latch causes one or more threads to wait at a “gate” until another
thread opens this gate, at which point these other threads can continue. It consists of a
count and operations for “causing a thread to wait until the count reaches zero” and
“decrementing the count.”
A cyclic barrier lets a set of threads wait for each other to reach a common barrier
point. The barrier is cyclic because it can be reused after the waiting threads are released.
This synchronizer is useful in applications involving a fixed-size party of threads that
must occasionally wait for each other.
An exchanger provides a synchronization point where threads can swap objects.
Each thread presents some object on entry to the exchanger’s exchange() method,
matches with a partner thread, and receives its partner’s object on return.
A semaphore maintains a set of permits for restricting the number of threads that
can access a limited resource. A thread attempting to acquire a permit when no permits
are available blocks until some other thread releases a permit.
A phaser is a more flexible cyclic barrier. Like a cyclic barrier, a phaser lets a group of
threads wait on a barrier; these threads continue after the last thread arrives. A phaser also
offers the equivalent of a barrier action. Unlike a cyclic barrier, which coordinates a fixed
number of threads, a phaser can coordinate a variable number of threads, which can register
at any time. To implement this capability, a phaser uses phases and phase numbers.
