Java当中自带了五种类型的 Synchronizer 分别是
**A counting semaphore. **
Conceptually, a semaphore maintains a set of permits.
Each acquire() blocks if necessary until a permit is available, and then takes it.
Each release() adds a permit, potentially releasing a blocking acquirer.
However, no actual permit objects are used;
the Semaphore just keeps a count of the number available and acts accordingly.
Semaphores are often used to restrict the number of threads than can access some (physical or logical) resource.
A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
A CountDownLatch is initialized with a given count.
The await methods block until the current count reaches zero due to invocations of the countDown() method, after which all waiting threads are released and any subsequent invocations of await return immediately.
This is a one-shot phenomenon – the count cannot be reset. If you need a version that resets the count, consider using a CyclicBarrier.
A CountDownLatchis a versatile synchronization tool and can be used for a number of purposes.
A CountDownLatch initialized with a count of one serves as a simple on/off latch, or gate:
all threads invoking await wait at the gate until it is opened by a thread invoking countDown().
A CountDownLatch initialized to N can be used to make one thread wait until N threads have completed some action, or some action has been completed N times.
A useful property of a CountDownLatch is that it doesn’t require that threads calling countDown wait for the count to reach zero before proceeding, it simply prevents any thread from proceeding past an await until all threads could pass.
A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
CyclicBarriers are useful in programs involving a fixed sized party of threads that must occasionally wait for each other.
The barrier is called cyclic because it can be re-used after the waiting threads are released.
A **CyclicBarrier **supports an optional Runnable command that is run once per barrier point, after the last thread in the party arrives, but before any threads are released.
This barrier action is useful for updating shared-state before any of the parties continue.
Registration. Unlike the case for other barriers, the number of parties registered to synchronize on a phaser may vary over time. Tasks may be registered at any time (using methods
bulkRegister(int), or forms of constructors establishing initial numbers of parties), and optionally deregistered upon any arrival (using
arriveAndDeregister()). As is the case with most basic synchronization constructs, registration and deregistration affect only internal counts; they do not establish any further internal bookkeeping, so tasks cannot query whether they are registered. (However, you can introduce such bookkeeping by subclassing this class.)
Synchronization. Like a
Phasermay be repeatedly awaited. Method
arriveAndAwaitAdvance()has effect analogous to
CyclicBarrier.await. Each generation of a phaser has an associated phase number. The phase number starts at zero, and advances when all parties arrive at the phaser, wrapping around to zero after reaching
Integer.MAX_VALUE. The use of phase numbers enables independent control of actions upon arrival at a phaser and upon awaiting others, via two kinds of methods that may be invoked by any registered party:
- Arrival. Methods
arriveAndDeregister()record arrival. These methods do not block, but return an associated arrival phase number; that is, the phase number of the phaser to which the arrival applied. When the final party for a given phase arrives, an optional action is performed and the phase advances. These actions are performed by the party triggering a phase advance, and are arranged by overriding method
onAdvance(int, int), which also controls termination. Overriding this method is similar to, but more flexible than, providing a barrier action to a
- Waiting. Method
awaitAdvance(int)requires an argument indicating an arrival phase number, and returns when the phaser advances to (or is already at) a different phase. Unlike similar constructions using
awaitAdvancecontinues to wait even if the waiting thread is interrupted. Interruptible and timeout versions are also available, but exceptions encountered while tasks wait interruptibly or with timeout do not change the state of the phaser. If necessary, you can perform any associated recovery within handlers of those exceptions, often after invoking
forceTermination. Phasers may also be used by tasks executing in a
ForkJoinPool. Progress is ensured if the pool’s parallelismLevel can accommodate the maximum number of simultaneously blocked parties.
Termination. A phaser may enter a termination state, that may be checked using method
isTerminated(). Upon termination, all synchronization methods immediately return without waiting for advance, as indicated by a negative return value. Similarly, attempts to register upon termination have no effect. Termination is triggered when an invocation of
true. The default implementation returns
trueif a deregistration has caused the number of registered parties to become zero. As illustrated below, when phasers control actions with a fixed number of iterations, it is often convenient to override this method to cause termination when the current phase number reaches a threshold. Method
forceTermination()is also available to abruptly release waiting threads and allow them to terminate.
Tiering. Phasers may be tiered (i.e., constructed in tree structures) to reduce contention. Phasers with large numbers of parties that would otherwise experience heavy synchronization contention costs may instead be set up so that groups of sub-phasers share a common parent. This may greatly increase throughput even though it incurs greater per-operation overhead.
In a tree of tiered phasers, registration and deregistration of child phasers with their parent are managed automatically. Whenever the number of registered parties of a child phaser becomes non-zero (as established in the
bulkRegister(int)), the child phaser is registered with its parent. Whenever the number of registered parties becomes zero as the result of an invocation of
arriveAndDeregister(), the child phaser is deregistered from its parent.
Monitoring. While synchronization methods may be invoked only by registered parties, the current state of a phaser may be monitored by any caller. At any given moment there are
getRegisteredParties()parties in total, of which
getArrivedParties()have arrived at the current phase (
getPhase()). When the remaining (
getUnarrivedParties()) parties arrive, the phase advances. The values returned by these methods may reflect transient states and so are not in general useful for synchronization control. Method
toString()returns snapshots of these state queries in a form convenient for informal monitoring.
A synchronization point at which threads can pair and swap elements within pairs. Each thread presents some object on entry to the
exchangemethod, matches with a partner thread, and receives its partner’s object on return. An Exchanger may be viewed as a bidirectional form of a
SynchronousQueue. Exchangers may be useful in applications such as genetic algorithms and pipeline designs.