Mercurial > hg > blitz_stable

comparison src/EDU/oswego/cs/dl/util/concurrent/WaitableBoolean.java @ 0:3dc0c5604566

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial checkin of blitz 2.0 fcs - no installer yet.
author Dan Creswell <dan.creswell@gmail.com>
date Sat, 21 Mar 2009 11:00:06 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:3dc0c5604566
1 /*
2 File: WaitableBoolean.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 19Jun1998 dl Create public version
12 */
13
14 package EDU.oswego.cs.dl.util.concurrent;
15
16 /**
17 * A class useful for offloading synch for boolean instance variables.
18 *
19 * <p>[<a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html"> Introduction to this package. </a>]
20 **/
21
22 public class WaitableBoolean extends SynchronizedBoolean {
23
24 /** Make a new WaitableBoolean with the given initial value **/
25 public WaitableBoolean(boolean initialValue) { super(initialValue); }
26
27
28 /**
29 * Make a new WaitableBoolean with the given initial value,
30 * and using the supplied lock.
31 **/
32 public WaitableBoolean(boolean initialValue, Object lock) {
33 super(initialValue, lock);
34 }
35
36
37 public boolean set(boolean newValue) {
38 synchronized (lock_) {
39 lock_.notifyAll();
40 return super.set(newValue);
41 }
42 }
43
44 public boolean commit(boolean assumedValue, boolean newValue) {
45 synchronized (lock_) {
46 boolean success = super.commit(assumedValue, newValue);
47 if (success) lock_.notifyAll();
48 return success;
49 }
50 }
51
52 public boolean complement() {
53 synchronized (lock_) {
54 lock_.notifyAll();
55 return super.complement();
56 }
57 }
58
59 public boolean and(boolean b) {
60 synchronized (lock_) {
61 lock_.notifyAll();
62 return super.and(b);
63 }
64 }
65
66 public boolean or(boolean b) {
67 synchronized (lock_) {
68 lock_.notifyAll();
69 return super.or(b);
70 }
71 }
72
73 public boolean xor(boolean b) {
74 synchronized (lock_) {
75 lock_.notifyAll();
76 return super.xor(b);
77 }
78 }
79
80 /**
81 * Wait until value is false, then run action if nonnull.
82 * The action is run with the synchronization lock held.
83 **/
84
85 public void whenFalse(Runnable action) throws InterruptedException {
86 synchronized (lock_) {
87 while (value_) lock_.wait();
88 if (action != null) action.run();
89 }
90 }
91
92 /**
93 * wait until value is true, then run action if nonnull.
94 * The action is run with the synchronization lock held.
95 **/
96 public void whenTrue(Runnable action) throws InterruptedException {
97 synchronized (lock_) {
98 while (!value_) lock_.wait();
99 if (action != null) action.run();
100 }
101 }
102
103 /**
104 * Wait until value equals c, then run action if nonnull.
105 * The action is run with the synchronization lock held.
106 **/
107
108 public void whenEqual(boolean c, Runnable action) throws InterruptedException {
109 synchronized (lock_) {
110 while (!(value_ == c)) lock_.wait();
111 if (action != null) action.run();
112 }
113 }
114
115 /**
116 * wait until value not equal to c, then run action if nonnull.
117 * The action is run with the synchronization lock held.
118 **/
119 public void whenNotEqual(boolean c, Runnable action) throws InterruptedException {
120 synchronized (lock_) {
121 while (!(value_ != c)) lock_.wait();
122 if (action != null) action.run();
123 }
124 }
125
126 }
127