KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > EDU > oswego > cs > dl > util > concurrent > CountDown


1 /*
2   File: CountDown.java
3
4   Originally written by Doug Lea and released into the public domain.
5   This may be used for any purposes whatsoever without acknowledgment.
6   Thanks for the assistance and support of Sun Microsystems Labs,
7   and everyone contributing, testing, and using this code.
8
9   History:
10   Date Who What
11   11Jun1998 dl Create public version
12 */
13
14 package EDU.oswego.cs.dl.util.concurrent;
15
16 /**
17  * A CountDown can serve as a simple one-shot barrier.
18  * A Countdown is initialized
19  * with a given count value. Each release decrements the count.
20  * All acquires block until the count reaches zero. Upon reaching
21  * zero all current acquires are unblocked and all
22  * subsequent acquires pass without blocking. This is a one-shot
23  * phenomenon -- the count cannot be reset.
24  * If you need a version that resets the count, consider
25  * using a Barrier.
26  * <p>
27  * <b>Sample usage.</b> Here are a set of classes in which
28  * a group of worker threads use a countdown to
29  * notify a driver when all threads are complete.
30  * <pre>
31  * class Worker implements Runnable {
32  * private final CountDown done;
33  * Worker(CountDown d) { done = d; }
34  * public void run() {
35  * doWork();
36  * done.release();
37  * }
38  * }
39  *
40  * class Driver { // ...
41  * void main() {
42  * CountDown done = new CountDown(N);
43  * for (int i = 0; i < N; ++i)
44  * new Thread(new Worker(done)).start();
45  * doSomethingElse();
46  * done.acquire(); // wait for all to finish
47  * }
48  * }
49  * </pre>
50  *
51  * <p>[<a HREF="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html"> Introduction to this package. </a>]
52  *
53 **/
54
55 public class CountDown implements Sync {
56   protected final int initialCount_;
57   protected int count_;
58
59   /** Create a new CountDown with given count value **/
60   public CountDown(int count) { count_ = initialCount_ = count; }
61
62   
63   /*
64     This could use double-check, but doesn't out of concern
65     for surprising effects on user programs stemming
66     from lack of memory barriers with lack of synch.
67   */
68   public void acquire() throws InterruptedException JavaDoc {
69     if (Thread.interrupted()) throw new InterruptedException JavaDoc();
70     synchronized(this) {
71       while (count_ > 0)
72         wait();
73     }
74   }
75
76
77   public boolean attempt(long msecs) throws InterruptedException JavaDoc {
78     if (Thread.interrupted()) throw new InterruptedException JavaDoc();
79     synchronized(this) {
80       if (count_ <= 0)
81         return true;
82       else if (msecs <= 0)
83         return false;
84       else {
85         long waitTime = msecs;
86         long start = System.currentTimeMillis();
87         for (;;) {
88           wait(waitTime);
89           if (count_ <= 0)
90             return true;
91           else {
92             waitTime = msecs - (System.currentTimeMillis() - start);
93             if (waitTime <= 0)
94               return false;
95           }
96         }
97       }
98     }
99   }
100
101   /**
102    * Decrement the count.
103    * After the initialCount'th release, all current and future
104    * acquires will pass
105    **/
106   public synchronized void release() {
107     if (--count_ == 0)
108       notifyAll();
109   }
110
111   /** Return the initial count value **/
112   public int initialCount() { return initialCount_; }
113
114
115   /**
116    * Return the current count value.
117    * This is just a snapshot value, that may change immediately
118    * after returning.
119    **/
120   public synchronized int currentCount() { return count_; }
121 }
122
123
Popular Tags