ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/jsr166e/extra/AtomicDouble.java
(Generate patch)

Comparing jsr166/src/jsr166e/extra/AtomicDouble.java (file contents):
Revision 1.9 by jsr166, Thu Oct 20 16:33:25 2011 UTC vs.
Revision 1.17 by jsr166, Mon Mar 4 16:09:25 2013 UTC

# Line 19 | 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><a name="bitEquals">This class compares primitive {@code double}
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 < * 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;
# Line 40 | Line 40 | import static java.lang.Double.longBitsT
40   public class AtomicDouble extends Number implements java.io.Serializable {
41      private static final long serialVersionUID = -8405198993435143622L;
42  
43 <    private volatile long value;
43 >    private transient volatile long value;
44  
45      /**
46       * Creates a new {@code AtomicDouble} with the given initial value.
# Line 123 | Line 123 | public class AtomicDouble extends Number
123       * if the current value is <a href="#bitEquals">bitwise equal</a>
124       * to the expected value.
125       *
126 <     * <p>May <a
126 >     * <p><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}.
128 >
129 >     * May fail spuriously and does not provide ordering guarantees</a>,
130 >     * so is only rarely an appropriate alternative to {@code compareAndSet}.
131       *
132       * @param expect the expected value
133       * @param update the new value
# Line 210 | Line 210 | public class AtomicDouble extends Number
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;
# Line 231 | Line 253 | public class AtomicDouble extends Number
253      private static sun.misc.Unsafe getUnsafe() {
254          try {
255              return sun.misc.Unsafe.getUnsafe();
256 <        } catch (SecurityException se) {
257 <            try {
258 <                return java.security.AccessController.doPrivileged
259 <                    (new java.security
260 <                     .PrivilegedExceptionAction<sun.misc.Unsafe>() {
261 <                        public sun.misc.Unsafe run() throws Exception {
262 <                            java.lang.reflect.Field f = sun.misc
263 <                                .Unsafe.class.getDeclaredField("theUnsafe");
264 <                            f.setAccessible(true);
265 <                            return (sun.misc.Unsafe) f.get(null);
266 <                        }});
267 <            } catch (java.security.PrivilegedActionException e) {
268 <                throw new RuntimeException("Could not initialize intrinsics",
269 <                                           e.getCause());
270 <            }
256 >        } catch (SecurityException tryReflectionInstead) {}
257 >        try {
258 >            return java.security.AccessController.doPrivileged
259 >            (new java.security.PrivilegedExceptionAction<sun.misc.Unsafe>() {
260 >                public sun.misc.Unsafe run() throws Exception {
261 >                    Class<sun.misc.Unsafe> k = sun.misc.Unsafe.class;
262 >                    for (java.lang.reflect.Field f : k.getDeclaredFields()) {
263 >                        f.setAccessible(true);
264 >                        Object x = f.get(null);
265 >                        if (k.isInstance(x))
266 >                            return k.cast(x);
267 >                    }
268 >                    throw new NoSuchFieldError("the Unsafe");
269 >                }});
270 >        } catch (java.security.PrivilegedActionException e) {
271 >            throw new RuntimeException("Could not initialize intrinsics",
272 >                                       e.getCause());
273          }
274      }
275   }

Diff Legend

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