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

Comparing jsr166/src/jsr166y/ThreadLocalRandom.java (file contents):
Revision 1.4 by jsr166, Mon Jul 20 21:54:51 2009 UTC vs.
Revision 1.13 by jsr166, Wed Aug 19 17:52:50 2009 UTC

# Line 5 | Line 5
5   */
6  
7   package jsr166y;
8 < import java.util.*;
8 >
9 > import java.util.Random;
10  
11   /**
12 < * A random number generator with the same properties as class {@link
13 < * Random} but isolated to the current Thread.  Like the global
14 < * generator used by the {@link java.lang.Math} class, a
15 < * ThreadLocalRandom is initialized with an internally generated seed
16 < * that may not otherwise be modified. When applicable, use of
17 < * ThreadLocalRandom rather than shared Random objects in concurrent
18 < * programs will typically encounter much less overhead and
19 < * contention.  ThreadLocalRandoms are particularly appropriate when
20 < * multiple tasks (for example, each a {@link ForkJoinTask}), use
21 < * random numbers in parallel in thread pools.
12 > * A random number generator isolated to the current thread.  Like the
13 > * global {@link java.util.Random} generator used by the {@link
14 > * java.lang.Math} class, a {@code ThreadLocalRandom} is initialized
15 > * with an internally generated seed that may not otherwise be
16 > * modified. When applicable, use of {@code ThreadLocalRandom} rather
17 > * than shared {@code Random} objects in concurrent programs will
18 > * typically encounter much less overhead and contention.  Use of
19 > * {@code ThreadLocalRandom} is particularly appropriate when multiple
20 > * tasks (for example, each a {@link ForkJoinTask}) use random numbers
21 > * in parallel in thread pools.
22   *
23   * <p>Usages of this class should typically be of the form:
24   * {@code ThreadLocalRandom.current().nextX(...)} (where
25   * {@code X} is {@code Int}, {@code Long}, etc).
26   * When all usages are of this form, it is never possible to
27 < * accidently share ThreadLocalRandoms across multiple threads.
27 > * accidently share a {@code ThreadLocalRandom} across multiple threads.
28   *
29   * <p>This class also provides additional commonly used bounded random
30   * generation methods.
31 + *
32 + * @since 1.7
33 + * @author Doug Lea
34   */
35   public class ThreadLocalRandom extends Random {
36      // same constants as Random, but must be redeclared because private
# Line 35 | Line 39 | public class ThreadLocalRandom extends R
39      private final static long mask = (1L << 48) - 1;
40  
41      /**
42 <     * The random seed. We can't use super.seed
42 >     * The random seed. We can't use super.seed.
43       */
44      private long rnd;
45  
# Line 73 | Line 77 | public class ThreadLocalRandom extends R
77      }
78  
79      /**
80 <     * Returns the current Thread's ThreadLocalRandom
81 <     * @return the current Thread's ThreadLocalRandom
80 >     * Returns the current thread's {@code ThreadLocalRandom}.
81 >     *
82 >     * @return the current thread's {@code ThreadLocalRandom}
83       */
84      public static ThreadLocalRandom current() {
85          return localRandom.get();
86      }
87  
88      /**
89 <     * Throws UnsupportedOperationException. Setting seeds in this
90 <     * generator is unsupported.
89 >     * Throws {@code UnsupportedOperationException}.  Setting seeds in
90 >     * this generator is not supported.
91 >     *
92       * @throws UnsupportedOperationException always
93       */
94      public void setSeed(long seed) {
# Line 93 | Line 99 | public class ThreadLocalRandom extends R
99      }
100  
101      protected int next(int bits) {
102 <        return (int)((rnd = (rnd * multiplier + addend) & mask) >>> (48-bits));
102 >        rnd = (rnd * multiplier + addend) & mask;
103 >        return (int) (rnd >>> (48-bits));
104      }
105  
106      /**
107       * Returns a pseudorandom, uniformly distributed value between the
108       * given least value (inclusive) and bound (exclusive).
109 +     *
110       * @param least the least value returned
111       * @param bound the upper bound (exclusive)
112       * @throws IllegalArgumentException if least greater than or equal
# Line 113 | Line 121 | public class ThreadLocalRandom extends R
121  
122      /**
123       * Returns a pseudorandom, uniformly distributed value
124 <     * between 0 (inclusive) and the specified value (exclusive)
124 >     * between 0 (inclusive) and the specified value (exclusive).
125 >     *
126       * @param n the bound on the random number to be returned.  Must be
127       *        positive.
128       * @return the next value
# Line 131 | Line 140 | public class ThreadLocalRandom extends R
140          while (n >= Integer.MAX_VALUE) {
141              int bits = next(2);
142              long half = n >>> 1;
143 <            long nextn = ((bits & 2) == 0)? half : n - half;
143 >            long nextn = ((bits & 2) == 0) ? half : n - half;
144              if ((bits & 1) == 0)
145                  offset += n - nextn;
146              n = nextn;
147          }
148 <        return offset + nextInt((int)n);
148 >        return offset + nextInt((int) n);
149      }
150  
151      /**
152       * Returns a pseudorandom, uniformly distributed value between the
153       * given least value (inclusive) and bound (exclusive).
154 +     *
155       * @param least the least value returned
156       * @param bound the upper bound (exclusive)
157       * @return the next value
# Line 156 | Line 166 | public class ThreadLocalRandom extends R
166  
167      /**
168       * Returns a pseudorandom, uniformly distributed {@code double} value
169 <     * between 0 (inclusive) and the specified value (exclusive)
169 >     * between 0 (inclusive) and the specified value (exclusive).
170 >     *
171       * @param n the bound on the random number to be returned.  Must be
172       *        positive.
173       * @return the next value
# Line 171 | Line 182 | public class ThreadLocalRandom extends R
182      /**
183       * Returns a pseudorandom, uniformly distributed value between the
184       * given least value (inclusive) and bound (exclusive).
185 +     *
186       * @param least the least value returned
187       * @param bound the upper bound (exclusive)
188       * @return the next value
# Line 183 | Line 195 | public class ThreadLocalRandom extends R
195          return nextDouble() * (bound - least) + least;
196      }
197  
198 +    private static final long serialVersionUID = -5851777807851030925L;
199   }

Diff Legend

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