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.1 by dl, Mon Jan 12 17:16:18 2009 UTC vs.
Revision 1.7 by jsr166, Thu Jul 23 19:25:45 2009 UTC

# Line 8 | Line 8 | package jsr166y;
8   import java.util.*;
9  
10   /**
11 < * A Random number generator with the same properties as {@link
11 > * A random number generator with the same properties as class {@link
12   * Random} but isolated to the current Thread.  Like the global
13 < * generator used by {@link java.lang.Math}, a ThreadLocalRandom is
14 < * initialized with an internally generated seed that may not
15 < * otherwise be modified. When applicable, use of ThreadLocalRandom
16 < * rather than shared Random objects in concurrent programs will
17 < * typically encounter less overhead and contention. The most common
18 < * usage form is: <code>ThreadLocalRandom.current().nextX()</code>.
13 > * generator used by the {@link java.lang.Math} class, a
14 > * ThreadLocalRandom is initialized with an internally generated seed
15 > * that may not otherwise be modified. When applicable, use of
16 > * ThreadLocalRandom rather than shared Random objects in concurrent
17 > * programs will typically encounter much less overhead and
18 > * contention.  ThreadLocalRandoms are particularly appropriate when
19 > * multiple tasks (for example, each a {@link ForkJoinTask}), use
20 > * random numbers in parallel in thread pools.
21 > *
22 > * <p>Usages of this class should typically be of the form:
23 > * {@code ThreadLocalRandom.current().nextX(...)} (where
24 > * {@code X} is {@code Int}, {@code Long}, etc).
25 > * When all usages are of this form, it is never possible to
26 > * accidently share ThreadLocalRandoms across multiple threads.
27   *
28   * <p>This class also provides additional commonly used bounded random
29   * generation methods.
30 + *
31 + * @since 1.7
32 + * @author Doug Lea
33   */
34   public class ThreadLocalRandom extends Random {
35      // same constants as Random, but must be redeclared because private
# Line 29 | Line 40 | public class ThreadLocalRandom extends R
40      /**
41       * The random seed. We can't use super.seed
42       */
43 <    private long rnd;
43 >    private long rnd;
44  
45      /**
46       * Initialization flag to permit the first and only allowed call
47       * to setSeed (inside Random constructor) to succeed.  We can't
48       * allow others since it would cause setting seed in one part of a
49 <     * program to inintentionally impact other usages by the thread.
49 >     * program to unintentionally impact other usages by the thread.
50       */
51      boolean initialized;
52  
# Line 44 | Line 55 | public class ThreadLocalRandom extends R
55      // each other.
56      private long pad0, pad1, pad2, pad3, pad4, pad5, pad6, pad7;
57  
58 +    /**
59 +     * The actual ThreadLocal
60 +     */
61      private static final ThreadLocal<ThreadLocalRandom> localRandom =
62          new ThreadLocal<ThreadLocalRandom>() {
63              protected ThreadLocalRandom initialValue() {
# Line 51 | Line 65 | public class ThreadLocalRandom extends R
65              }
66      };
67  
68 <    ThreadLocalRandom() { // construct only in localRandom.initialValue
69 <        super(); // super constructor calls setSeed
68 >
69 >    /**
70 >     * Constructor called only by localRandom.initialValue.
71 >     * We rely on the fact that the superclass no-arg constructor
72 >     * invokes setSeed exactly once to initialize.
73 >     */
74 >    ThreadLocalRandom() {
75 >        super();
76      }
77  
78      /**
79 <     * Returns the current Thread's ThreadLocalRandom
79 >     * Returns the current Thread's ThreadLocalRandom.
80       * @return the current Thread's ThreadLocalRandom
81       */
82      public static ThreadLocalRandom current() {
# Line 66 | Line 86 | public class ThreadLocalRandom extends R
86      /**
87       * Throws UnsupportedOperationException. Setting seeds in this
88       * generator is unsupported.
89 <     * @throw UnsupportedOperationException always
89 >     * @throws UnsupportedOperationException always
90       */
91 <    public void setSeed(long seed) {
91 >    public void setSeed(long seed) {
92          if (initialized)
93              throw new UnsupportedOperationException();
94          initialized = true;
# Line 105 | Line 125 | public class ThreadLocalRandom extends R
125      public long nextLong(long n) {
126          if (n <= 0)
127              throw new IllegalArgumentException("n must be positive");
128 +        // Divide n by two until small enough for nextInt. On each
129 +        // iteration (at most 31 of them but usually much less),
130 +        // randomly choose both whether to include high bit in result
131 +        // (offset) and whether to continue with the lower vs upper
132 +        // half (which makes a difference only if odd).
133          long offset = 0;
134 <        while (n >= Integer.MAX_VALUE) { // randomly pick half range
135 <            int bits = next(2); // 2nd bit for odd vs even split
134 >        while (n >= Integer.MAX_VALUE) {
135 >            int bits = next(2);
136              long half = n >>> 1;
137              long nextn = ((bits & 2) == 0)? half : n - half;
138              if ((bits & 1) == 0)
139                  offset += n - nextn;
140              n = nextn;
141          }
142 <        return offset + nextInt((int)n);
142 >        return offset + nextInt((int) n);
143      }
144  
145      /**
# Line 161 | Line 186 | public class ThreadLocalRandom extends R
186          return nextDouble() * (bound - least) + least;
187      }
188  
189 < }
189 > }

Diff Legend

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