Mercurial > hg > blitz_stable

comparison src/EDU/oswego/cs/dl/util/concurrent/WaitableChar.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: WaitableChar.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 23Jun1998 dl Create public version
12 */
13
14 package EDU.oswego.cs.dl.util.concurrent;
15
16 /**
17 * A class useful for offloading waiting and signalling operations
18 * on single char variables.
19 * <p>
20 * <p>[<a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html"> Introduction to this package. </a>]
21 **/
22
23 public class WaitableChar extends SynchronizedChar {
24 /**
25 * Make a new WaitableChar with the given initial value,
26 * and using its own internal lock.
27 **/
28 public WaitableChar(char initialValue) {
29 super(initialValue);
30 }
31
32 /**
33 * Make a new WaitableChar with the given initial value,
34 * and using the supplied lock.
35 **/
36 public WaitableChar(char initialValue, Object lock) {
37 super(initialValue, lock);
38 }
39
40
41 public char set(char newValue) {
42 synchronized (lock_) {
43 lock_.notifyAll();
44 return super.set(newValue);
45 }
46 }
47
48 public boolean commit(char assumedValue, char newValue) {
49 synchronized (lock_) {
50 boolean success = super.commit(assumedValue, newValue);
51 if (success) lock_.notifyAll();
52 return success;
53 }
54 }
55
56
57 public char add(char amount) {
58 synchronized (lock_) {
59 lock_.notifyAll();
60 return super.add(amount);
61 }
62 }
63
64 public char subtract(char amount) {
65 synchronized (lock_) {
66 lock_.notifyAll();
67 return super.subtract(amount);
68 }
69 }
70
71 public char multiply(char factor) {
72 synchronized (lock_) {
73 lock_.notifyAll();
74 return super.multiply(factor);
75 }
76 }
77
78 public char divide(char factor) {
79 synchronized (lock_) {
80 lock_.notifyAll();
81 return super.divide(factor);
82 }
83 }
84
85
86 /**
87 * Wait until value equals c, then run action if nonnull.
88 * The action is run with the synchronization lock held.
89 **/
90
91 public void whenEqual(char c, Runnable action) throws InterruptedException {
92 synchronized(lock_) {
93 while (!(value_ == c)) lock_.wait();
94 if (action != null) action.run();
95 }
96 }
97
98 /**
99 * wait until value not equal to c, then run action if nonnull.
100 * The action is run with the synchronization lock held.
101 **/
102 public void whenNotEqual(char c, Runnable action) throws InterruptedException {
103 synchronized (lock_) {
104 while (!(value_ != c)) lock_.wait();
105 if (action != null) action.run();
106 }
107 }
108
109 /**
110 * wait until value less than or equal to c, then run action if nonnull.
111 * The action is run with the synchronization lock held.
112 **/
113 public void whenLessEqual(char c, Runnable action) throws InterruptedException {
114 synchronized (lock_) {
115 while (!(value_ <= c)) lock_.wait();
116 if (action != null) action.run();
117 }
118 }
119
120 /**
121 * wait until value less than c, then run action if nonnull.
122 * The action is run with the synchronization lock held.
123 **/
124 public void whenLess(char c, Runnable action) throws InterruptedException {
125 synchronized (lock_) {
126 while (!(value_ < c)) lock_.wait();
127 if (action != null) action.run();
128 }
129 }
130
131 /**
132 * wait until value greater than or equal to c, then run action if nonnull.
133 * The action is run with the synchronization lock held.
134 **/
135 public void whenGreaterEqual(char c, Runnable action) throws InterruptedException {
136 synchronized (lock_) {
137 while (!(value_ >= c)) lock_.wait();
138 if (action != null) action.run();
139 }
140 }
141
142 /**
143 * wait until value greater than c, then run action if nonnull.
144 * The action is run with the synchronization lock held.
145 **/
146 public void whenGreater(char c, Runnable action) throws InterruptedException {
147 synchronized (lock_) {
148 while (!(value_ > c)) lock_.wait();
149 if (action != null) action.run();
150 }
151 }
152
153 }
154