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.4 by jsr166, Tue Aug 9 19:10:29 2011 UTC vs.
Revision 1.11 by jsr166, Tue Oct 25 19:21:27 2011 UTC

#	Line 6 | Line 6
6		*/
7
8		package jsr166e.extra;
9	+
10		import static java.lang.Double.doubleToRawLongBits;
11		import static java.lang.Double.longBitsToDouble;
12
#	Line 18 | Line 19 | import static java.lang.Double.longBitsT
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>This class differs from the primitive double {@code ==} operator
23	<	* and from {@link Double#equals} in that it uses purely bitwise
24	<	* equality in methods such as {@link #compareAndSet}, as if
25	<	* implemented by:
22	>	* <p><a name="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	<	* boolean bitEquals(double x, double y) {
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	+	*
37		* @author Doug Lea
38		* @author Martin Buchholz
39		*/
40		public class AtomicDouble extends Number implements java.io.Serializable {
41	<	static final long serialVersionUID = -8405198993435143622L;
37	<
38	<	// setup to use Unsafe.compareAndSwapLong for updates
39	<	private static final sun.misc.Unsafe unsafe = getUnsafe();
40	<	private static final long valueOffset;
41	<
42	<	static {
43	<	try {
44	<	valueOffset = unsafe.objectFieldOffset
45	<	(AtomicDouble.class.getDeclaredField("value"));
46	<	} catch (Exception ex) { throw new Error(ex); }
47	<	}
41	>	private static final long serialVersionUID = -8405198993435143622L;
42
43	<	private volatile long value;
43	>	private volatile transient long value;
44
45		/**
46	<	* 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 58 | 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 77 | 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		/**
#	Line 86 | Line 83 | public class AtomicDouble extends Number
83		* @param newValue the new value
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 96 | 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 (unsafe.compareAndSwapLong(this, valueOffset,
101	<	currentBits, newBits))
104	<	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 122 | 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>
126	>	* <p>May <a
127	>	* href="http://download.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/package-summary.html#Spurious">
128	>	* fail spuriously</a>
129		* and does not provide ordering guarantees, so is only rarely an
130		* appropriate alternative to {@code compareAndSet}.
131		*
132		* @param expect the expected value
133		* @param update the new value
134	<	* @return true if successful.
134	>	* @return {@code true} if successful
135		*/
136		public final boolean weakCompareAndSet(double expect, double update) {
137		return compareAndSet(expect, update);
#	Line 144 | Line 145 | public class AtomicDouble extends Number
145		*/
146		public final double getAndAdd(double delta) {
147		while (true) {
148	<	long currentBits = value;
149	<	long nextBits = doubleToRawLongBits(longBitsToDouble(currentBits) + delta);
150	<	if (unsafe.compareAndSwapLong(this, valueOffset,
151	<	currentBits, nextBits))
152	<	return longBitsToDouble(currentBits);
148	>	long current = value;
149	>	double currentVal = longBitsToDouble(current);
150	>	double nextVal = currentVal + delta;
151	>	long next = doubleToRawLongBits(nextVal);
152	>	if (unsafe.compareAndSwapLong(this, valueOffset, current, next))
153	>	return currentVal;
154		}
155		}
156
#	Line 159 | Line 161 | public class AtomicDouble extends Number
161		* @return the updated value
162		*/
163		public final double addAndGet(double delta) {
164	<	for (;;) {
165	<	double current = get();
166	<	double next = current + delta;
167	<	if (compareAndSet(current, next))
168	<	return next;
164	>	while (true) {
165	>	long current = value;
166	>	double currentVal = longBitsToDouble(current);
167	>	double nextVal = currentVal + delta;
168	>	long next = doubleToRawLongBits(nextVal);
169	>	if (unsafe.compareAndSwapLong(this, valueOffset, current, next))
170	>	return nextVal;
171		}
172		}
173
174		/**
175		* Returns the String representation of the current value.
176	<	* @return the String representation of the current value.
176	>	* @return the String representation of the current value
177		*/
178		public String toString() {
179		return Double.toString(get());
180		}
181
178	–
182		/**
183		* Returns the value of this {@code AtomicDouble} as an {@code int}
184		* after a narrowing primitive conversion.
185		*/
186		public int intValue() {
187	<	return (int)get();
187	>	return (int) get();
188		}
189
190		/**
191	<	* Returns the value of this {@code AtomicDouble} as a {@code long}.
191	>	* Returns the value of this {@code AtomicDouble} as a {@code long}
192	>	* after a narrowing primitive conversion.
193		*/
194		public long longValue() {
195	<	return (long)get();
195	>	return (long) get();
196		}
197
198		/**
199		* Returns the value of this {@code AtomicDouble} as a {@code float}
200	<	* after a widening primitive conversion.
200	>	* after a narrowing primitive conversion.
201		*/
202		public float floatValue() {
203	<	return (float)get();
203	>	return (float) get();
204		}
205
206		/**
207	<	* Returns the value of this {@code AtomicDouble} as a {@code double}
204	<	* after a widening primitive conversion.
207	>	* Returns the value of this {@code AtomicDouble} as a {@code double}.
208		*/
209		public double doubleValue() {
210		return get();
211		}
212
213		/**
214	+	* Saves the state to a stream (that is, serializes it).
215	+	*
216	+	* @serialData The current value is emitted (a {@code double}).
217	+	*/
218	+	private void writeObject(java.io.ObjectOutputStream s)
219	+	throws java.io.IOException{
220	+	s.defaultWriteObject();
221	+
222	+	s.writeDouble(get());
223	+	}
224	+
225	+	/**
226	+	* Reconstitutes the instance from a stream (that is, deserializes it).
227	+	*/
228	+	private void readObject(java.io.ObjectInputStream s)
229	+	throws java.io.IOException, ClassNotFoundException {
230	+	s.defaultReadObject();
231	+
232	+	set(s.readDouble());
233	+	}
234	+
235	+	// Unsafe mechanics
236	+	private static final sun.misc.Unsafe unsafe = getUnsafe();
237	+	private static final long valueOffset;
238	+
239	+	static {
240	+	try {
241	+	valueOffset = unsafe.objectFieldOffset
242	+	(AtomicDouble.class.getDeclaredField("value"));
243	+	} catch (Exception ex) { throw new Error(ex); }
244	+	}
245	+
246	+	/**
247		* Returns a sun.misc.Unsafe.  Suitable for use in a 3rd party package.
248		* Replace with a simple call to Unsafe.getUnsafe when integrating
249		* into a jdk.
#	Line 234 | Line 270 | public class AtomicDouble extends Number
270		}
271		}
272		}
237	–
273		}

Diff Legend

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