Mercurial > hg > blitz_stable

comparison src/EDU/oswego/cs/dl/util/concurrent/WaitableRef.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: WaitableRef.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 Object reference 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 WaitableRef extends SynchronizedRef {
23
24 /**
25 * Create a WaitableRef initially holding the given reference
26 * and using its own internal lock.
27 **/
28 public WaitableRef(Object initialValue) {
29 super(initialValue);
30 }
31
32 /**
33 * Make a new WaitableRef with the given initial value,
34 * and using the supplied lock.
35 **/
36 public WaitableRef(Object initialValue, Object lock) {
37 super(initialValue, lock);
38 }
39
40 public Object set(Object newValue) {
41 synchronized (lock_) {
42 lock_.notifyAll();
43 return super.set(newValue);
44 }
45 }
46
47 public boolean commit(Object assumedValue, Object newValue) {
48 synchronized (lock_) {
49 boolean success = super.commit(assumedValue, newValue);
50 if (success) lock_.notifyAll();
51 return success;
52 }
53 }
54
55 /**
56 * Wait until value is null, then run action if nonnull.
57 * The action is run with the synchronization lock held.
58 **/
59
60 public void whenNull(Runnable action) throws InterruptedException {
61 synchronized (lock_) {
62 while (value_ != null) lock_.wait();
63 if (action != null) action.run();
64 }
65 }
66
67 /**
68 * wait until value is nonnull, then run action if nonnull.
69 * The action is run with the synchronization lock held.
70 **/
71 public void whenNotNull(Runnable action) throws InterruptedException {
72 synchronized (lock_) {
73 while (value_ == null) lock_.wait();
74 if (action != null) action.run();
75 }
76 }
77
78 /**
79 * Wait until value equals c, then run action if nonnull.
80 * The action is run with the synchronization lock held.
81 **/
82
83 public void whenEqual(Object c, Runnable action) throws InterruptedException {
84 synchronized (lock_) {
85 while (!(value_ == c)) lock_.wait();
86 if (action != null) action.run();
87 }
88 }
89
90 /**
91 * wait until value not equal to c, then run action if nonnull.
92 * The action is run with the synchronization lock held.
93 **/
94 public void whenNotEqual(Object c, Runnable action) throws InterruptedException {
95 synchronized (lock_) {
96 while (!(value_ != c)) lock_.wait();
97 if (action != null) action.run();
98 }
99 }
100
101 }
102