|
Code - Class EDU.oswego.cs.dl.util.concurrent.SynchronizedLong
1 /*
2 File: SynchronizedLong.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 15Apr2003 dl Removed redundant "synchronized" for multiply()
13 23jan04 dl synchronize self-swap case for swap
14 */
15
16 package EDU.oswego.cs.dl.util.concurrent;
17
18 /**
19 * A class useful for offloading synch for long instance variables.
20 *
21 * <p>[<a HREF="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html"> Introduction to this package. </a>]
22 **/
23
24 public class SynchronizedLong extends SynchronizedVariable implements Comparable, Cloneable {
25
26 protected long value_;
27
28 /**
29 * Make a new SynchronizedLong with the given initial value,
30 * and using its own internal lock.
31 **/
32 public SynchronizedLong(long initialValue) {
33 super();
34 value_ = initialValue;
35 }
36
37 /**
38 * Make a new SynchronizedLong with the given initial value,
39 * and using the supplied lock.
40 **/
41 public SynchronizedLong(long initialValue, Object lock) {
42 super(lock);
43 value_ = initialValue;
44 }
45
46 /**
47 * Return the current value
48 **/
49 public final long get() { synchronized(lock_) { return value_; } }
50
51 /**
52 * Set to newValue.
53 * @return the old value
54 **/
55
56 public long set(long newValue) {
57 synchronized (lock_) {
58 long old = value_;
59 value_ = newValue;
60 return old;
61 }
62 }
63
64 /**
65 * Set value to newValue only if it is currently assumedValue.
66 * @return true if successful
67 **/
68 public boolean commit(long assumedValue, long newValue) {
69 synchronized(lock_) {
70 boolean success = (assumedValue == value_);
71 if (success) value_ = newValue;
72 return success;
73 }
74 }
75
76 /**
77 * Atomically swap values with another SynchronizedLong.
78 * Uses identityHashCode to avoid deadlock when
79 * two SynchronizedLongs attempt to simultaneously swap with each other.
80 * @return the new value
81 **/
82
83 public long swap(SynchronizedLong other) {
84 if (other == this) return get();
85 SynchronizedLong fst = this;
86 SynchronizedLong 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 * Increment the value.
101 * @return the new value
102 **/
103 public long increment() {
104 synchronized (lock_) {
105 return ++value_;
106 }
107 }
108
109 /**
110 * Decrement the value.
111 * @return the new value
112 **/
113 public long decrement() {
114 synchronized (lock_) {
115 return --value_;
116 }
117 }
118
119 /**
120 * Add amount to value (i.e., set value += amount)
121 * @return the new value
122 **/
123 public long add(long amount) {
124 synchronized (lock_) {
125 return value_ += amount;
126 }
127 }
128
129 /**
130 * Subtract amount from value (i.e., set value -= amount)
131 * @return the new value
132 **/
133 public long subtract(long amount) {
134 synchronized (lock_) {
135 return value_ -= amount;
136 }
137 }
138
139 /**
140 * Multiply value by factor (i.e., set value *= factor)
141 * @return the new value
142 **/
143 public long multiply(long factor) {
144 synchronized (lock_) {
145 return value_ *= factor;
146 }
147 }
148
149 /**
150 * Divide value by factor (i.e., set value /= factor)
151 * @return the new value
152 **/
153 public long divide(long factor) {
154 synchronized (lock_) {
155 return value_ /= factor;
156 }
157 }
158
159 /**
160 * Set the value to the negative of its old value
161 * @return the new value
162 **/
163 public long negate() {
164 synchronized (lock_) {
165 value_ = -value_;
166 return value_;
167 }
168 }
169
170 /**
171 * Set the value to its complement
172 * @return the new value
173 **/
174 public long complement() {
175 synchronized (lock_) {
176 value_ = ~value_;
177 return value_;
178 }
179 }
180
181 /**
182 * Set value to value & b.
183 * @return the new value
184 **/
185 public long and(long b) {
186 synchronized (lock_) {
187 value_ = value_ & b;
188 return value_;
189 }
190 }
191
192 /**
193 * Set value to value | b.
194 * @return the new value
195 **/
196 public long or(long b) {
197 synchronized (lock_) {
198 value_ = value_ | b;
199 return value_;
200 }
201 }
202
203
204 /**
205 * Set value to value ^ b.
206 * @return the new value
207 **/
208 public long xor(long b) {
209 synchronized (lock_) {
210 value_ = value_ ^ b;
211 return value_;
212 }
213 }
214
215
216 public int compareTo(long other) {
217 long val = get();
218 return (val < other)? -1 : (val == other)? 0 : 1;
219 }
220
221 public int compareTo(SynchronizedLong other) {
222 return compareTo(other.get());
223 }
224
225 public int compareTo(Object other) {
226 return compareTo((SynchronizedLong)other);
227 }
228
229 public boolean equals(Object other) {
230 if (other != null &&
231 other instanceof SynchronizedLong)
232 return get() == ((SynchronizedLong)other).get();
233 else
234 return false;
235 }
236
237 public int hashCode() { // same expression as java.lang.Long
238 long v = get();
239 return (int)(v ^ (v >> 32));
240 }
241
242 public String toString() { return String.valueOf(get()); }
243
244 }
245
246
Java API By Example, From Geeks To Geeks. |
Conditions of Use |
About Us
© 2002 - 2005, KickJava.com, or its affiliates