Mercurial > hg > blitz_condensed

comparison src/EDU/oswego/cs/dl/util/concurrent/SynchronizedBoolean.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: SynchronizedBoolean.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 SynchronizedBoolean extends SynchronizedVariable implements Comparable, Cloneable {
23 protected boolean value_;
24
25 /**
26 * Make a new SynchronizedBoolean with the given initial value,
27 * and using its own internal lock.
28 **/
29 public SynchronizedBoolean(boolean initialValue) {
30 super();
31 value_ = initialValue;
32 }
33
34 /**
35 * Make a new SynchronizedBoolean with the given initial value,
36 * and using the supplied lock.
37 **/
38 public SynchronizedBoolean(boolean initialValue, Object lock) {
39 super(lock);
40 value_ = initialValue;
41 }
42
43 /**
44 * Return the current value
45 **/
46 public final boolean get() { synchronized(lock_) { return value_; } }
47
48 /**
49 * Set to newValue.
50 * @return the old value
51 **/
52
53 public boolean set(boolean newValue) {
54 synchronized (lock_) {
55 boolean old = value_;
56 value_ = newValue;
57 return old;
58 }
59 }
60
61 /**
62 * Set value to newValue only if it is currently assumedValue.
63 * @return true if successful
64 **/
65 public boolean commit(boolean assumedValue, boolean newValue) {
66 synchronized(lock_) {
67 boolean success = (assumedValue == value_);
68 if (success) value_ = newValue;
69 return success;
70 }
71 }
72
73 /**
74 * Atomically swap values with another SynchronizedBoolean.
75 * Uses identityHashCode to avoid deadlock when
76 * two SynchronizedBooleans attempt to simultaneously swap with each other.
77 * (Note: Ordering via identyHashCode is not strictly guaranteed
78 * by the language specification to return unique, orderable
79 * values, but in practice JVMs rely on them being unique.)
80 * @return the new value
81 **/
82
83 public boolean swap(SynchronizedBoolean other) {
84 if (other == this) return get();
85 SynchronizedBoolean fst = this;
86 SynchronizedBoolean snd = other;
87 if (System.identityHashCode(fst) > System.identityHashCode(snd)) {
88 fst = other;
89 snd = this;
90 }
91 synchronized(fst.lock_) {
92 synchronized(snd.lock_) {
93 fst.set(snd.set(fst.get()));
94 return get();
95 }
96 }
97 }
98
99 /**
100 * Set the value to its complement
101 * @return the new value
102 **/
103 public boolean complement() {
104 synchronized (lock_) {
105 value_ = !value_;
106 return value_;
107 }
108 }
109
110 /**
111 * Set value to value &amp; b.
112 * @return the new value
113 **/
114 public boolean and(boolean b) {
115 synchronized (lock_) {
116 value_ = value_ & b;
117 return value_;
118 }
119 }
120
121 /**
122 * Set value to value | b.
123 * @return the new value
124 **/
125 public boolean or(boolean b) {
126 synchronized (lock_) {
127 value_ = value_ | b;
128 return value_;
129 }
130 }
131
132
133 /**
134 * Set value to value ^ b.
135 * @return the new value
136 **/
137 public boolean xor(boolean b) {
138 synchronized (lock_) {
139 value_ = value_ ^ b;
140 return value_;
141 }
142 }
143
144
145 public int compareTo(boolean other) {
146 boolean val = get();
147 return (val == other)? 0 : (val)? 1 : -1;
148 }
149
150 public int compareTo(SynchronizedBoolean other) {
151 return compareTo(other.get());
152 }
153
154 public int compareTo(Object other) {
155 return compareTo((SynchronizedBoolean)other);
156 }
157
158
159 public boolean equals(Object other) {
160 if (other != null &&
161 other instanceof SynchronizedBoolean)
162 return get() == ((SynchronizedBoolean)other).get();
163 else
164 return false;
165 }
166
167 public int hashCode() {
168 boolean b = get();
169 return (b)? 3412688 : 8319343; // entirely arbitrary
170 }
171
172 public String toString() { return String.valueOf(get()); }
173
174 }
175