--- jsr166/src/jsr166y/ThreadLocalRandom.java	2009/01/12 20:46:29	1.2
+++ jsr166/src/jsr166y/ThreadLocalRandom.java	2009/07/25 00:34:00	1.10
@@ -5,7 +5,8 @@
  */
 
 package jsr166y;
-import java.util.*;
+
+import java.util.Random;
 
 /**
  * A random number generator with the same properties as class {@link
@@ -18,15 +19,18 @@ import java.util.*;
  * contention.  ThreadLocalRandoms are particularly appropriate when
  * multiple tasks (for example, each a {@link ForkJoinTask}), use
  * random numbers in parallel in thread pools.
- * 
+ *
  * <p>Usages of this class should typically be of the form:
- * <code>ThreadLocalRandom.current().nextX(...)</code> (where
- * <code>X</code> is <code>Int</code>, <code>Long</code>, etc).
+ * {@code ThreadLocalRandom.current().nextX(...)} (where
+ * {@code X} is {@code Int}, {@code Long}, etc).
  * When all usages are of this form, it is never possible to
  * accidently share ThreadLocalRandoms across multiple threads.
  *
  * <p>This class also provides additional commonly used bounded random
  * generation methods.
+ *
+ * @since 1.7
+ * @author Doug Lea
  */
 public class ThreadLocalRandom extends Random {
     // same constants as Random, but must be redeclared because private
@@ -35,9 +39,9 @@ public class ThreadLocalRandom extends R
     private final static long mask = (1L << 48) - 1;
 
     /**
-     * The random seed. We can't use super.seed
+     * The random seed. We can't use super.seed.
      */
-    private long rnd; 
+    private long rnd;
 
     /**
      * Initialization flag to permit the first and only allowed call
@@ -65,7 +69,7 @@ public class ThreadLocalRandom extends R
 
     /**
      * Constructor called only by localRandom.initialValue.
-     * We rely on the fact that the superclass no-arg constructor 
+     * We rely on the fact that the superclass no-arg constructor
      * invokes setSeed exactly once to initialize.
      */
     ThreadLocalRandom() {
@@ -73,7 +77,8 @@ public class ThreadLocalRandom extends R
     }
 
     /**
-     * Returns the current Thread's ThreadLocalRandom
+     * Returns the current Thread's ThreadLocalRandom.
+     *
      * @return the current Thread's ThreadLocalRandom
      */
     public static ThreadLocalRandom current() {
@@ -83,9 +88,10 @@ public class ThreadLocalRandom extends R
     /**
      * Throws UnsupportedOperationException. Setting seeds in this
      * generator is unsupported.
-     * @throw UnsupportedOperationException always
+     *
+     * @throws UnsupportedOperationException always
      */
-    public void setSeed(long seed) { 
+    public void setSeed(long seed) {
         if (initialized)
             throw new UnsupportedOperationException();
         initialized = true;
@@ -93,12 +99,14 @@ public class ThreadLocalRandom extends R
     }
 
     protected int next(int bits) {
-        return (int)((rnd = (rnd * multiplier + addend) & mask) >>> (48-bits));
+        rnd = (rnd * multiplier + addend) & mask;
+        return (int) (rnd >>> (48-bits));
     }
 
     /**
      * Returns a pseudorandom, uniformly distributed value between the
      * given least value (inclusive) and bound (exclusive).
+     *
      * @param least the least value returned
      * @param bound the upper bound (exclusive)
      * @throws IllegalArgumentException if least greater than or equal
@@ -113,7 +121,8 @@ public class ThreadLocalRandom extends R
 
     /**
      * Returns a pseudorandom, uniformly distributed value
-     * between 0 (inclusive) and the specified value (exclusive)
+     * between 0 (inclusive) and the specified value (exclusive).
+     *
      * @param n the bound on the random number to be returned.  Must be
      *        positive.
      * @return the next value
@@ -126,22 +135,23 @@ public class ThreadLocalRandom extends R
         // iteration (at most 31 of them but usually much less),
         // randomly choose both whether to include high bit in result
         // (offset) and whether to continue with the lower vs upper
-        // half (which makes a difference only if odd). 
+        // half (which makes a difference only if odd).
         long offset = 0;
         while (n >= Integer.MAX_VALUE) {
-            int bits = next(2); 
+            int bits = next(2);
             long half = n >>> 1;
-            long nextn = ((bits & 2) == 0)? half : n - half;
+            long nextn = ((bits & 2) == 0) ? half : n - half;
             if ((bits & 1) == 0)
                 offset += n - nextn;
             n = nextn;
         }
-        return offset + nextInt((int)n);
+        return offset + nextInt((int) n);
     }
 
     /**
      * Returns a pseudorandom, uniformly distributed value between the
      * given least value (inclusive) and bound (exclusive).
+     *
      * @param least the least value returned
      * @param bound the upper bound (exclusive)
      * @return the next value
@@ -156,7 +166,8 @@ public class ThreadLocalRandom extends R
 
     /**
      * Returns a pseudorandom, uniformly distributed {@code double} value
-     * between 0 (inclusive) and the specified value (exclusive)
+     * between 0 (inclusive) and the specified value (exclusive).
+     *
      * @param n the bound on the random number to be returned.  Must be
      *        positive.
      * @return the next value
@@ -171,6 +182,7 @@ public class ThreadLocalRandom extends R
     /**
      * Returns a pseudorandom, uniformly distributed value between the
      * given least value (inclusive) and bound (exclusive).
+     *
      * @param least the least value returned
      * @param bound the upper bound (exclusive)
      * @return the next value
@@ -183,4 +195,5 @@ public class ThreadLocalRandom extends R
         return nextDouble() * (bound - least) + least;
     }
 
-}
\ No newline at end of file
+    private static final long serialVersionUID = -5851777807851030925L;
+}