--- jsr166/src/jsr166e/extra/AtomicDouble.java	2011/10/20 16:33:25	1.9
+++ jsr166/src/jsr166e/extra/AtomicDouble.java	2013/02/11 06:29:57	1.15
@@ -25,11 +25,11 @@ import static java.lang.Double.longBitsT
  * which differs from both the primitive double {@code ==} operator
  * and from {@link Double#equals}, as if implemented by:
  *  <pre> {@code
- * boolean bitEquals(double x, double y) {
+ * static boolean bitEquals(double x, double y) {
  *   long xBits = Double.doubleToRawLongBits(x);
  *   long yBits = Double.doubleToRawLongBits(y);
  *   return xBits == yBits;
- * }}</pre>
+ * }}</pre></a>
  *
  * @see jsr166e.DoubleAdder
  * @see jsr166e.DoubleMaxUpdater
@@ -40,7 +40,7 @@ import static java.lang.Double.longBitsT
 public class AtomicDouble extends Number implements java.io.Serializable {
     private static final long serialVersionUID = -8405198993435143622L;
 
-    private volatile long value;
+    private transient volatile long value;
 
     /**
      * Creates a new {@code AtomicDouble} with the given initial value.
@@ -210,6 +210,28 @@ public class AtomicDouble extends Number
         return get();
     }
 
+    /**
+     * Saves the state to a stream (that is, serializes it).
+     *
+     * @serialData The current value is emitted (a {@code double}).
+     */
+    private void writeObject(java.io.ObjectOutputStream s)
+        throws java.io.IOException {
+        s.defaultWriteObject();
+
+        s.writeDouble(get());
+    }
+
+    /**
+     * Reconstitutes the instance from a stream (that is, deserializes it).
+     */
+    private void readObject(java.io.ObjectInputStream s)
+        throws java.io.IOException, ClassNotFoundException {
+        s.defaultReadObject();
+
+        set(s.readDouble());
+    }
+
     // Unsafe mechanics
     private static final sun.misc.Unsafe unsafe = getUnsafe();
     private static final long valueOffset;
@@ -231,21 +253,23 @@ public class AtomicDouble extends Number
     private static sun.misc.Unsafe getUnsafe() {
         try {
             return sun.misc.Unsafe.getUnsafe();
-        } catch (SecurityException se) {
-            try {
-                return java.security.AccessController.doPrivileged
-                    (new java.security
-                     .PrivilegedExceptionAction<sun.misc.Unsafe>() {
-                        public sun.misc.Unsafe run() throws Exception {
-                            java.lang.reflect.Field f = sun.misc
-                                .Unsafe.class.getDeclaredField("theUnsafe");
-                            f.setAccessible(true);
-                            return (sun.misc.Unsafe) f.get(null);
-                        }});
-            } catch (java.security.PrivilegedActionException e) {
-                throw new RuntimeException("Could not initialize intrinsics",
-                                           e.getCause());
-            }
+        } catch (SecurityException tryReflectionInstead) {}
+        try {
+            return java.security.AccessController.doPrivileged
+            (new java.security.PrivilegedExceptionAction<sun.misc.Unsafe>() {
+                public sun.misc.Unsafe run() throws Exception {
+                    Class<sun.misc.Unsafe> k = sun.misc.Unsafe.class;
+                    for (java.lang.reflect.Field f : k.getDeclaredFields()) {
+                        f.setAccessible(true);
+                        Object x = f.get(null);
+                        if (k.isInstance(x))
+                            return k.cast(x);
+                    }
+                    throw new NoSuchFieldError("the Unsafe");
+                }});
+        } catch (java.security.PrivilegedActionException e) {
+            throw new RuntimeException("Could not initialize intrinsics",
+                                       e.getCause());
         }
     }
 }