\file
Countdown
.d
\brief A latch that fires after a specified count.
Written by Doug Lea with assistance from members of JCP JSR-166
Expert Group and released to the domain, as explained at
http:
//creativecommons.org/licenses/publicdomain
Ported to D by Ben Hinkle.
Email comments and bug reports to ben.hinkle@gmail.com
revision 2.0
- class
CountDownLatch
;
- \class
CountDownLatch
\brief 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 wait 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 wait 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
CountDownLatch
is 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 wait 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 wait until all threads could pass.
Sample usage: Here is a pair of classes in which a group
of worker threads use two countdown latches:
- The first is a start signal that prevents any worker from proceeding
until the driver is ready for them to proceed;
- The second is a completion signal that allows the driver to wait
until all workers have completed.
class Driver {
void main() {
CountDownLatch startSignal;
CountDownLatch doneSignal;
this() {
startSignal = new CountDownLatch(1);
doneSignal = new CountDownLatch(N);
}
for (int i = 0; i < N; ++i) { // create and start threads
Worker work = new Worker(startSignal, doneSignal);
new Thread(&work.run).start();
doSomethingElse(); // don't let run yet
startSignal.countDown(); // let all threads proceed
doSomethingElse();
doneSignal.wait(); // wait for all to finish
}
}
class Worker {
private CountDownLatch startSignal;
private CountDownLatch doneSignal;
this(CountDownLatch startSignal, CountDownLatch doneSignal) {
this.startSignal = startSignal;
this.doneSignal = doneSignal;
}
int run() {
startSignal.wait();
doWork();
doneSignal.countDown();
return 0;
}
void doWork() { ... }
}
- this(int count);
- Constructs a CountDownLatch initialized with the given
count.
\param count the number of times countDown must be invoked before
threads can pass through wait
- void
wait
();
- Causes the current thread to
wait
until the latch has counted
down to zero.
If the current count is zero then this method returns
immediately. If the current count is greater than zero then
the current thread becomes disabled for thread scheduling
purposes and lies dormant until the count reaches zero due to
invocations of the countDown method.
- bool
wait
(long timeout, TimeUnit unit);
- Causes the current thread to
wait
until the latch has counted
down to zero.
If the current count is zero then this method returns
immediately with the value true.
If the current count is greater than zero then the current
thread becomes disabled for thread scheduling purposes and lies
dormant until one of three things happen:
- The count reaches zero due to invocations of the
countDown method; or
- The specified waiting time elapses.
If the count reaches zero then the method returns with the
value true.
If the specified waiting time elapses then the value
false is returned. If the time is less than or equal to
zero, the method will not
wait
at all.
\param timeout the maximum time to
wait
\param unit the time unit of the timeout argument.
\return true if the count reached zero and false
if the waiting time elapsed before the count reached zero.
- void
countDown
();
- Decrements the count of the latch, releasing all waiting threads
if the count reaches zero.
If the current count is greater than zero then it is
decremented. If the new count is zero then all waiting threads
are re-enabled for thread scheduling purposes.
If the current count equals zero then nothing happens.
- long
count
();
- Returns the current
count
. This method is typically used for
debugging and testing purposes.
\return the current
count
.
- char[]
toString
();
- Returns a string identifying this latch, as well as its state.
The state, in brackets, includes the String "Count ="
followed by the current count.
\return a string identifying this latch, as well as its state
|