ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/jsr166e/extra/AtomicDouble.java

Comparing jsr166/src/jsr166e/extra/AtomicDouble.java (file contents):
Revision 1.1 by jsr166, Tue Aug 9 04:05:25 2011 UTC vs.
Revision 1.18 by jsr166, Mon Mar 4 16:12:26 2013 UTC

#	Line 1 | Line 1
1		/*
2	<	* Written by Doug Lea with assistance from members of JCP JSR-166
3	<	* Expert Group and released to the public domain, as explained at
2	>	* Written by Doug Lea and Martin Buchholz with assistance from
3	>	* members of JCP JSR-166 Expert Group and released to the public
4	>	* domain, as explained at
5		* http://creativecommons.org/publicdomain/zero/1.0/
6		*/
7
8		package jsr166e.extra;
9	+
10		import static java.lang.Double.doubleToRawLongBits;
11		import static java.lang.Double.longBitsToDouble;
10	–	import sun.misc.Unsafe;
12
13		/**
14		* A {@code double} value that may be updated atomically.  See the
15		* {@link java.util.concurrent.atomic} package specification for
16	<	* description of the properties of atomic variables. An
17	<	* {@code AtomicDouble} is used in applications such as atomically
18	<	* incremented sequence numbers, and cannot be used as a replacement
19	<	* for a {@link java.lang.Double}. However, this class does extend
20	<	* {@code Number} to allow uniform access by tools and utilities that
21	<	* deal with numerically-based classes.
16	>	* description of the properties of atomic variables.  An {@code
17	>	* AtomicDouble} is used in applications such as atomic accumulation,
18	>	* and cannot be used as a replacement for a {@link Double}.  However,
19	>	* this class does extend {@code Number} to allow uniform access by
20	>	* tools and utilities that deal with numerically-based classes.
21	>	*
22	>	* <p id="bitEquals">This class compares primitive {@code double}
23	>	* values in methods such as {@link #compareAndSet} by comparing their
24	>	* bitwise representation using {@link Double#doubleToRawLongBits},
25	>	* which differs from both the primitive double {@code ==} operator
26	>	* and from {@link Double#equals}, as if implemented by:
27	>	*  <pre> {@code
28	>	* static boolean bitEquals(double x, double y) {
29	>	*   long xBits = Double.doubleToRawLongBits(x);
30	>	*   long yBits = Double.doubleToRawLongBits(y);
31	>	*   return xBits == yBits;
32	>	* }}</pre>
33	>	*
34	>	* @see jsr166e.DoubleAdder
35	>	* @see jsr166e.DoubleMaxUpdater
36		*
22	–	* @since 1.5
37		* @author Doug Lea
38	+	* @author Martin Buchholz
39		*/
40		public class AtomicDouble extends Number implements java.io.Serializable {
41	<	private static final long serialVersionUID = 1927816293512124184L;
41	>	private static final long serialVersionUID = -8405198993435143622L;
42
43	<	// setup to use Unsafe.compareAndSwapLong for updates
29	<	private static final Unsafe unsafe = Unsafe.getUnsafe();
30	<	private static final long valueOffset;
31	<
32	<	/**
33	<	* Records whether the underlying JVM supports lockless
34	<	* compareAndSwap for longs. While the Unsafe.compareAndSwapLong
35	<	* method works in either case, some constructions should be
36	<	* handled at Java level to avoid locking user-visible locks.
37	<	*/
38	<	static final boolean VM_SUPPORTS_LONG_CAS = VMSupportsCS8();
43	>	private transient volatile long value;
44
45		/**
46	<	* Returns whether underlying JVM supports lockless CompareAndSet
42	<	* for longs. Called only once and cached in VM_SUPPORTS_LONG_CAS.
43	<	*/
44	<	private static native boolean VMSupportsCS8();
45	<
46	<	static {
47	<	try {
48	<	valueOffset = unsafe.objectFieldOffset
49	<	(AtomicDouble.class.getDeclaredField("value"));
50	<	} catch (Exception ex) { throw new Error(ex); }
51	<	}
52	<
53	<	private volatile long value;
54	<
55	<	/**
56	<	* Creates a new AtomicDouble with the given initial value.
46	>	* Creates a new {@code AtomicDouble} with the given initial value.
47		*
48		* @param initialValue the initial value
49		*/
#	Line 62 | Line 52 | public class AtomicDouble extends Number
52		}
53
54		/**
55	<	* Creates a new AtomicDouble with initial value {@code 0.0}.
55	>	* Creates a new {@code AtomicDouble} with initial value {@code 0.0}.
56		*/
57	<	public AtomicDouble() { this(0.0); }
57	>	public AtomicDouble() {
58	>	// assert doubleToRawLongBits(0.0) == 0L;
59	>	}
60
61		/**
62		* Gets the current value.
#	Line 81 | Line 73 | public class AtomicDouble extends Number
73		* @param newValue the new value
74		*/
75		public final void set(double newValue) {
76	<	value = doubleToRawLongBits(newValue);
76	>	long next = doubleToRawLongBits(newValue);
77	>	value = next;
78		}
79
80		/**
81		* Eventually sets to the given value.
82		*
83		* @param newValue the new value
91	–	* @since 1.6
84		*/
85		public final void lazySet(double newValue) {
86	<	unsafe.putOrderedLong(this, valueOffset, doubleToRawLongBits(newValue));
86	>	long next = doubleToRawLongBits(newValue);
87	>	unsafe.putOrderedLong(this, valueOffset, next);
88		}
89
90		/**
#	Line 101 | Line 94 | public class AtomicDouble extends Number
94		* @return the previous value
95		*/
96		public final double getAndSet(double newValue) {
97	<	long newBits = doubleToRawLongBits(newValue);
97	>	long next = doubleToRawLongBits(newValue);
98		while (true) {
99	<	long currentBits = value;
100	<	if (compareAndSet(currentBits, newBits))
101	<	return longBitsToDouble(currentBits);
99	>	long current = value;
100	>	if (unsafe.compareAndSwapLong(this, valueOffset, current, next))
101	>	return longBitsToDouble(current);
102		}
103		}
104
105		/**
106		* Atomically sets the value to the given updated value
107	<	* if the current value {@code ==} the expected value.
107	>	* if the current value is <a href="#bitEquals">bitwise equal</a>
108	>	* to the expected value.
109		*
110		* @param expect the expected value
111		* @param update the new value
112	<	* @return true if successful. False return indicates that
113	<	* the actual value was not equal to the expected value.
112	>	* @return {@code true} if successful. False return indicates that
113	>	* the actual value was not bitwise equal to the expected value.
114		*/
115		public final boolean compareAndSet(double expect, double update) {
116		return unsafe.compareAndSwapLong(this, valueOffset,
#	Line 126 | Line 120 | public class AtomicDouble extends Number
120
121		/**
122		* Atomically sets the value to the given updated value
123	<	* if the current value {@code ==} the expected value.
123	>	* if the current value is <a href="#bitEquals">bitwise equal</a>
124	>	* to the expected value.
125		*
126	<	* <p>May <a href="package-summary.html#Spurious">fail spuriously</a>
127	<	* and does not provide ordering guarantees, so is only rarely an
128	<	* appropriate alternative to {@code compareAndSet}.
126	>	* <p><a
127	>	* href="http://download.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/package-summary.html#Spurious">
128	>	* May fail spuriously and does not provide ordering guarantees</a>,
129	>	* so is only rarely an appropriate alternative to {@code compareAndSet}.
130		*
131		* @param expect the expected value
132		* @param update the new value
133	<	* @return true if successful.
133	>	* @return {@code true} if successful
134		*/
135		public final boolean weakCompareAndSet(double expect, double update) {
136		return compareAndSet(expect, update);
#	Line 148 | Line 144 | public class AtomicDouble extends Number
144		*/
145		public final double getAndAdd(double delta) {
146		while (true) {
147	<	long currentBits = value;
148	<	long nextBits = doubleToRawLongBits(longBitsToDouble(currentBits) + delta);
149	<	if (compareAndSet(currentBits, nextBits))
150	<	return longBitsToDouble(currentBits);
147	>	long current = value;
148	>	double currentVal = longBitsToDouble(current);
149	>	double nextVal = currentVal + delta;
150	>	long next = doubleToRawLongBits(nextVal);
151	>	if (unsafe.compareAndSwapLong(this, valueOffset, current, next))
152	>	return currentVal;
153		}
154		}
155
#	Line 162 | Line 160 | public class AtomicDouble extends Number
160		* @return the updated value
161		*/
162		public final double addAndGet(double delta) {
163	<	for (;;) {
164	<	double current = get();
165	<	double next = current + delta;
166	<	if (compareAndSet(current, next))
167	<	return next;
163	>	while (true) {
164	>	long current = value;
165	>	double currentVal = longBitsToDouble(current);
166	>	double nextVal = currentVal + delta;
167	>	long next = doubleToRawLongBits(nextVal);
168	>	if (unsafe.compareAndSwapLong(this, valueOffset, current, next))
169	>	return nextVal;
170		}
171		}
172
173		/**
174		* Returns the String representation of the current value.
175	<	* @return the String representation of the current value.
175	>	* @return the String representation of the current value
176		*/
177		public String toString() {
178		return Double.toString(get());
179		}
180
181	–
181		/**
182		* Returns the value of this {@code AtomicDouble} as an {@code int}
183		* after a narrowing primitive conversion.
184		*/
185		public int intValue() {
186	<	return (int)get();
186	>	return (int) get();
187		}
188
189		/**
190	<	* Returns the value of this {@code AtomicDouble} as a {@code long}.
190	>	* Returns the value of this {@code AtomicDouble} as a {@code long}
191	>	* after a narrowing primitive conversion.
192		*/
193		public long longValue() {
194	<	return (long)get();
194	>	return (long) get();
195		}
196
197		/**
198		* Returns the value of this {@code AtomicDouble} as a {@code float}
199	<	* after a widening primitive conversion.
199	>	* after a narrowing primitive conversion.
200		*/
201		public float floatValue() {
202	<	return (float)get();
202	>	return (float) get();
203		}
204
205		/**
206	<	* Returns the value of this {@code AtomicDouble} as a {@code double}
207	<	* after a widening primitive conversion.
206	>	* Returns the value of this {@code AtomicDouble} as a {@code double}.
207		*/
208		public double doubleValue() {
209		return get();
210		}
211
212	+	/**
213	+	* Saves the state to a stream (that is, serializes it).
214	+	*
215	+	* @serialData The current value is emitted (a {@code double}).
216	+	*/
217	+	private void writeObject(java.io.ObjectOutputStream s)
218	+	throws java.io.IOException {
219	+	s.defaultWriteObject();
220	+
221	+	s.writeDouble(get());
222	+	}
223	+
224	+	/**
225	+	* Reconstitutes the instance from a stream (that is, deserializes it).
226	+	*/
227	+	private void readObject(java.io.ObjectInputStream s)
228	+	throws java.io.IOException, ClassNotFoundException {
229	+	s.defaultReadObject();
230	+
231	+	set(s.readDouble());
232	+	}
233	+
234	+	// Unsafe mechanics
235	+	private static final sun.misc.Unsafe unsafe = getUnsafe();
236	+	private static final long valueOffset;
237	+
238	+	static {
239	+	try {
240	+	valueOffset = unsafe.objectFieldOffset
241	+	(AtomicDouble.class.getDeclaredField("value"));
242	+	} catch (Exception ex) { throw new Error(ex); }
243	+	}
244	+
245	+	/**
246	+	* Returns a sun.misc.Unsafe.  Suitable for use in a 3rd party package.
247	+	* Replace with a simple call to Unsafe.getUnsafe when integrating
248	+	* into a jdk.
249	+	*
250	+	* @return a sun.misc.Unsafe
251	+	*/
252	+	private static sun.misc.Unsafe getUnsafe() {
253	+	try {
254	+	return sun.misc.Unsafe.getUnsafe();
255	+	} catch (SecurityException tryReflectionInstead) {}
256	+	try {
257	+	return java.security.AccessController.doPrivileged
258	+	(new java.security.PrivilegedExceptionAction<sun.misc.Unsafe>() {
259	+	public sun.misc.Unsafe run() throws Exception {
260	+	Class<sun.misc.Unsafe> k = sun.misc.Unsafe.class;
261	+	for (java.lang.reflect.Field f : k.getDeclaredFields()) {
262	+	f.setAccessible(true);
263	+	Object x = f.get(null);
264	+	if (k.isInstance(x))
265	+	return k.cast(x);
266	+	}
267	+	throw new NoSuchFieldError("the Unsafe");
268	+	}});
269	+	} catch (java.security.PrivilegedActionException e) {
270	+	throw new RuntimeException("Could not initialize intrinsics",
271	+	e.getCause());
272	+	}
273	+	}
274		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines