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

Comparing jsr166/src/jsr166e/extra/AtomicDoubleArray.java (file contents):
Revision 1.4 by jsr166, Tue Oct 25 19:21:27 2011 UTC vs.
Revision 1.11 by jsr166, Mon Jul 22 16:47:46 2013 UTC

# Line 14 | Line 14 | import static java.lang.Double.longBitsT
14   * See the {@link java.util.concurrent.atomic} package specification
15   * for description of the properties of atomic variables.
16   *
17 < * <p><a name="bitEquals">This class compares primitive {@code double}
17 > * <p id="bitEquals">This class compares primitive {@code double}
18   * values in methods such as {@link #compareAndSet} by comparing their
19   * bitwise representation using {@link Double#doubleToRawLongBits},
20   * which differs from both the primitive double {@code ==} operator
# Line 162 | Line 162 | public class AtomicDoubleArray implement
162       * if the current value is <a href="#bitEquals">bitwise equal</a>
163       * to the expected value.
164       *
165 <     * <p>May <a
165 >     * <p><a
166       * href="http://download.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/package-summary.html#Spurious">
167 <     * fail spuriously</a>
168 <     * and does not provide ordering guarantees, so is only rarely an
169 <     * appropriate alternative to {@code compareAndSet}.
167 >     * May fail spuriously and does not provide ordering guarantees</a>,
168 >     * so is only rarely an appropriate alternative to {@code compareAndSet}.
169       *
170       * @param i the index
171       * @param expect the expected value
# Line 238 | Line 237 | public class AtomicDoubleArray implement
237      /**
238       * Saves the state to a stream (that is, serializes it).
239       *
240 +     * @param s the stream
241 +     * @throws java.io.IOException if an I/O error occurs
242       * @serialData The length of the array is emitted (int), followed by all
243       *             of its elements (each a {@code double}) in the proper order.
244       */
245      private void writeObject(java.io.ObjectOutputStream s)
246 <        throws java.io.IOException{
246 >        throws java.io.IOException {
247          s.defaultWriteObject();
248  
249          // Write out array length
# Line 256 | Line 257 | public class AtomicDoubleArray implement
257  
258      /**
259       * Reconstitutes the instance from a stream (that is, deserializes it).
260 +     * @param s the stream
261 +     * @throws ClassNotFoundException if the class of a serialized object
262 +     *         could not be found
263 +     * @throws java.io.IOException if an I/O error occurs
264       */
265      private void readObject(java.io.ObjectInputStream s)
266          throws java.io.IOException, ClassNotFoundException {
# Line 300 | Line 305 | public class AtomicDoubleArray implement
305      private static sun.misc.Unsafe getUnsafe() {
306          try {
307              return sun.misc.Unsafe.getUnsafe();
308 <        } catch (SecurityException se) {
309 <            try {
310 <                return java.security.AccessController.doPrivileged
311 <                    (new java.security
312 <                     .PrivilegedExceptionAction<sun.misc.Unsafe>() {
313 <                        public sun.misc.Unsafe run() throws Exception {
314 <                            java.lang.reflect.Field f = sun.misc
315 <                                .Unsafe.class.getDeclaredField("theUnsafe");
316 <                            f.setAccessible(true);
317 <                            return (sun.misc.Unsafe) f.get(null);
318 <                        }});
319 <            } catch (java.security.PrivilegedActionException e) {
320 <                throw new RuntimeException("Could not initialize intrinsics",
321 <                                           e.getCause());
322 <            }
308 >        } catch (SecurityException tryReflectionInstead) {}
309 >        try {
310 >            return java.security.AccessController.doPrivileged
311 >            (new java.security.PrivilegedExceptionAction<sun.misc.Unsafe>() {
312 >                public sun.misc.Unsafe run() throws Exception {
313 >                    Class<sun.misc.Unsafe> k = sun.misc.Unsafe.class;
314 >                    for (java.lang.reflect.Field f : k.getDeclaredFields()) {
315 >                        f.setAccessible(true);
316 >                        Object x = f.get(null);
317 >                        if (k.isInstance(x))
318 >                            return k.cast(x);
319 >                    }
320 >                    throw new NoSuchFieldError("the Unsafe");
321 >                }});
322 >        } catch (java.security.PrivilegedActionException e) {
323 >            throw new RuntimeException("Could not initialize intrinsics",
324 >                                       e.getCause());
325          }
326      }
327   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines