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

Comparing jsr166/src/main/java/util/SplittableRandom.java (file contents):
Revision 1.24 by dl, Mon Oct 7 10:54:27 2013 UTC vs.
Revision 1.40 by jsr166, Tue Oct 3 22:27:04 2017 UTC

# Line 25 | Line 25
25  
26   package java.util;
27  
28 – import java.net.NetworkInterface;
28   import java.util.concurrent.atomic.AtomicLong;
29 + import java.util.function.DoubleConsumer;
30   import java.util.function.IntConsumer;
31   import java.util.function.LongConsumer;
32 < import java.util.function.DoubleConsumer;
33 < import java.util.stream.StreamSupport;
32 > import java.util.stream.DoubleStream;
33   import java.util.stream.IntStream;
34   import java.util.stream.LongStream;
35 < import java.util.stream.DoubleStream;
35 > import java.util.stream.StreamSupport;
36  
37   /**
38   * A generator of uniform pseudorandom values applicable for use in
# Line 53 | Line 52 | import java.util.stream.DoubleStream;
52   * types and ranges, but similar properties are expected to hold, at
53   * least approximately, for others as well. The <em>period</em>
54   * (length of any series of generated values before it repeats) is at
55 < * least 2<sup>64</sup>. </li>
55 > * least 2<sup>64</sup>.
56   *
57 < * <li> Method {@link #split} constructs and returns a new
57 > * <li>Method {@link #split} constructs and returns a new
58   * SplittableRandom instance that shares no mutable state with the
59   * current instance. However, with very high probability, the
60   * values collectively generated by the two objects have the same
61   * statistical properties as if the same quantity of values were
62   * generated by a single thread using a single {@code
63 < * SplittableRandom} object.  </li>
63 > * SplittableRandom} object.
64   *
65   * <li>Instances of SplittableRandom are <em>not</em> thread-safe.
66   * They are designed to be split, not shared, across threads. For
# Line 72 | Line 71 | import java.util.stream.DoubleStream;
71   *
72   * <li>This class provides additional methods for generating random
73   * streams, that employ the above techniques when used in {@code
74 < * stream.parallel()} mode.</li>
74 > * stream.parallel()} mode.
75   *
76   * </ul>
77   *
# Line 140 | Line 139 | public final class SplittableRandom {
139       * other cases, this split must be performed in a thread-safe
140       * manner, so we use an AtomicLong to represent the seed rather
141       * than use an explicit SplittableRandom. To bootstrap the
142 <     * defaultGen, we start off using a seed based on current time and
143 <     * network interface address unless the java.util.secureRandomSeed
144 <     * property is set. This serves as a slimmed-down (and insecure)
145 <     * variant of SecureRandom that also avoids stalls that may occur
147 <     * when using /dev/random.
142 >     * defaultGen, we start off using a seed based on current time
143 >     * unless the java.util.secureRandomSeed property is set. This
144 >     * serves as a slimmed-down (and insecure) variant of SecureRandom
145 >     * that also avoids stalls that may occur when using /dev/random.
146       *
147       * It is a relatively simple matter to apply the basic design here
148       * to use 128 bit seeds. However, emulating 128bit arithmetic and
# Line 221 | Line 219 | public final class SplittableRandom {
219          return seed += gamma;
220      }
221  
222 +    // IllegalArgumentException messages
223 +    static final String BAD_BOUND = "bound must be positive";
224 +    static final String BAD_RANGE = "bound must be greater than origin";
225 +    static final String BAD_SIZE  = "size must be non-negative";
226 +
227      /**
228       * The seed generator for default constructors.
229       */
230 <    private static final AtomicLong defaultGen = new AtomicLong(initialSeed());
231 <
232 <    private static long initialSeed() {
233 <        String pp = java.security.AccessController.doPrivileged(
234 <                new sun.security.action.GetPropertyAction(
235 <                        "java.util.secureRandomSeed"));
236 <        if (pp != null && pp.equalsIgnoreCase("true")) {
230 >    private static final AtomicLong defaultGen
231 >        = new AtomicLong(mix64(System.currentTimeMillis()) ^
232 >                         mix64(System.nanoTime()));
233 >
234 >    // at end of <clinit> to survive static initialization circularity
235 >    static {
236 >        if (java.security.AccessController.doPrivileged(
237 >            new java.security.PrivilegedAction<Boolean>() {
238 >                public Boolean run() {
239 >                    return Boolean.getBoolean("java.util.secureRandomSeed");
240 >                }})) {
241              byte[] seedBytes = java.security.SecureRandom.getSeed(8);
242 <            long s = (long)(seedBytes[0]) & 0xffL;
242 >            long s = (long)seedBytes[0] & 0xffL;
243              for (int i = 1; i < 8; ++i)
244 <                s = (s << 8) | ((long)(seedBytes[i]) & 0xffL);
245 <            return s;
239 <        }
240 <        long h = 0L;
241 <        try {
242 <            Enumeration<NetworkInterface> ifcs =
243 <                    NetworkInterface.getNetworkInterfaces();
244 <            boolean retry = false; // retry once if getHardwareAddress is null
245 <            while (ifcs.hasMoreElements()) {
246 <                NetworkInterface ifc = ifcs.nextElement();
247 <                if (!ifc.isVirtual()) { // skip fake addresses
248 <                    byte[] bs = ifc.getHardwareAddress();
249 <                    if (bs != null) {
250 <                        int n = bs.length;
251 <                        int m = Math.min(n >>> 1, 4);
252 <                        for (int i = 0; i < m; ++i)
253 <                            h = (h << 16) ^ (bs[i] << 8) ^ bs[n-1-i];
254 <                        if (m < 4)
255 <                            h = (h << 8) ^ bs[n-1-m];
256 <                        h = mix64(h);
257 <                        break;
258 <                    }
259 <                    else if (!retry)
260 <                        retry = true;
261 <                    else
262 <                        break;
263 <                }
264 <            }
265 <        } catch (Exception ignore) {
244 >                s = (s << 8) | ((long)seedBytes[i] & 0xffL);
245 >            defaultGen.set(s);
246          }
267 –        return (h ^ mix64(System.currentTimeMillis()) ^
268 –                mix64(System.nanoTime()));
247      }
248  
271 –    // IllegalArgumentException messages
272 –    static final String BadBound = "bound must be positive";
273 –    static final String BadRange = "bound must be greater than origin";
274 –    static final String BadSize  = "size must be non-negative";
275 –
249      /*
250       * Internal versions of nextX methods used by streams, as well as
251       * the public nextX(origin, bound) methods.  These exist mainly to
# Line 402 | Line 375 | public final class SplittableRandom {
375       * may, and typically does, vary across program invocations.
376       */
377      public SplittableRandom() { // emulate defaultGen.split()
378 <        long s = defaultGen.getAndAdd(2 * GOLDEN_GAMMA);
378 >        long s = defaultGen.getAndAdd(GOLDEN_GAMMA << 1);
379          this.seed = mix64(s);
380          this.gamma = mixGamma(s + GOLDEN_GAMMA);
381      }
# Line 426 | Line 399 | public final class SplittableRandom {
399      }
400  
401      /**
402 +     * Fills a user-supplied byte array with generated pseudorandom bytes.
403 +     *
404 +     * @param  bytes the byte array to fill with pseudorandom bytes
405 +     * @throws NullPointerException if bytes is null
406 +     * @since  10
407 +     */
408 +    public void nextBytes(byte[] bytes) {
409 +        int i = 0;
410 +        int len = bytes.length;
411 +        for (int words = len >> 3; words--> 0; ) {
412 +            long rnd = nextLong();
413 +            for (int n = 8; n--> 0; rnd >>>= Byte.SIZE)
414 +                bytes[i++] = (byte)rnd;
415 +        }
416 +        if (i < len)
417 +            for (long rnd = nextLong(); i < len; rnd >>>= Byte.SIZE)
418 +                bytes[i++] = (byte)rnd;
419 +    }
420 +
421 +    /**
422       * Returns a pseudorandom {@code int} value.
423       *
424       * @return a pseudorandom {@code int} value
# Line 445 | Line 438 | public final class SplittableRandom {
438       */
439      public int nextInt(int bound) {
440          if (bound <= 0)
441 <            throw new IllegalArgumentException(BadBound);
441 >            throw new IllegalArgumentException(BAD_BOUND);
442          // Specialize internalNextInt for origin 0
443          int r = mix32(nextSeed());
444          int m = bound - 1;
# Line 473 | Line 466 | public final class SplittableRandom {
466       */
467      public int nextInt(int origin, int bound) {
468          if (origin >= bound)
469 <            throw new IllegalArgumentException(BadRange);
469 >            throw new IllegalArgumentException(BAD_RANGE);
470          return internalNextInt(origin, bound);
471      }
472  
# Line 497 | Line 490 | public final class SplittableRandom {
490       */
491      public long nextLong(long bound) {
492          if (bound <= 0)
493 <            throw new IllegalArgumentException(BadBound);
493 >            throw new IllegalArgumentException(BAD_BOUND);
494          // Specialize internalNextLong for origin 0
495          long r = mix64(nextSeed());
496          long m = bound - 1;
# Line 525 | Line 518 | public final class SplittableRandom {
518       */
519      public long nextLong(long origin, long bound) {
520          if (origin >= bound)
521 <            throw new IllegalArgumentException(BadRange);
521 >            throw new IllegalArgumentException(BAD_RANGE);
522          return internalNextLong(origin, bound);
523      }
524  
# Line 551 | Line 544 | public final class SplittableRandom {
544       */
545      public double nextDouble(double bound) {
546          if (!(bound > 0.0))
547 <            throw new IllegalArgumentException(BadBound);
547 >            throw new IllegalArgumentException(BAD_BOUND);
548          double result = (mix64(nextSeed()) >>> 11) * DOUBLE_UNIT * bound;
549          return (result < bound) ?  result : // correct for rounding
550              Double.longBitsToDouble(Double.doubleToLongBits(bound) - 1);
# Line 570 | Line 563 | public final class SplittableRandom {
563       */
564      public double nextDouble(double origin, double bound) {
565          if (!(origin < bound))
566 <            throw new IllegalArgumentException(BadRange);
566 >            throw new IllegalArgumentException(BAD_RANGE);
567          return internalNextDouble(origin, bound);
568      }
569  
# Line 598 | Line 591 | public final class SplittableRandom {
591       */
592      public IntStream ints(long streamSize) {
593          if (streamSize < 0L)
594 <            throw new IllegalArgumentException(BadSize);
594 >            throw new IllegalArgumentException(BAD_SIZE);
595          return StreamSupport.intStream
596              (new RandomIntsSpliterator
597               (this, 0L, streamSize, Integer.MAX_VALUE, 0),
# Line 639 | Line 632 | public final class SplittableRandom {
632      public IntStream ints(long streamSize, int randomNumberOrigin,
633                            int randomNumberBound) {
634          if (streamSize < 0L)
635 <            throw new IllegalArgumentException(BadSize);
635 >            throw new IllegalArgumentException(BAD_SIZE);
636          if (randomNumberOrigin >= randomNumberBound)
637 <            throw new IllegalArgumentException(BadRange);
637 >            throw new IllegalArgumentException(BAD_RANGE);
638          return StreamSupport.intStream
639              (new RandomIntsSpliterator
640               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 665 | Line 658 | public final class SplittableRandom {
658       */
659      public IntStream ints(int randomNumberOrigin, int randomNumberBound) {
660          if (randomNumberOrigin >= randomNumberBound)
661 <            throw new IllegalArgumentException(BadRange);
661 >            throw new IllegalArgumentException(BAD_RANGE);
662          return StreamSupport.intStream
663              (new RandomIntsSpliterator
664               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 684 | Line 677 | public final class SplittableRandom {
677       */
678      public LongStream longs(long streamSize) {
679          if (streamSize < 0L)
680 <            throw new IllegalArgumentException(BadSize);
680 >            throw new IllegalArgumentException(BAD_SIZE);
681          return StreamSupport.longStream
682              (new RandomLongsSpliterator
683               (this, 0L, streamSize, Long.MAX_VALUE, 0L),
# Line 725 | Line 718 | public final class SplittableRandom {
718      public LongStream longs(long streamSize, long randomNumberOrigin,
719                              long randomNumberBound) {
720          if (streamSize < 0L)
721 <            throw new IllegalArgumentException(BadSize);
721 >            throw new IllegalArgumentException(BAD_SIZE);
722          if (randomNumberOrigin >= randomNumberBound)
723 <            throw new IllegalArgumentException(BadRange);
723 >            throw new IllegalArgumentException(BAD_RANGE);
724          return StreamSupport.longStream
725              (new RandomLongsSpliterator
726               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 751 | Line 744 | public final class SplittableRandom {
744       */
745      public LongStream longs(long randomNumberOrigin, long randomNumberBound) {
746          if (randomNumberOrigin >= randomNumberBound)
747 <            throw new IllegalArgumentException(BadRange);
747 >            throw new IllegalArgumentException(BAD_RANGE);
748          return StreamSupport.longStream
749              (new RandomLongsSpliterator
750               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 770 | Line 763 | public final class SplittableRandom {
763       */
764      public DoubleStream doubles(long streamSize) {
765          if (streamSize < 0L)
766 <            throw new IllegalArgumentException(BadSize);
766 >            throw new IllegalArgumentException(BAD_SIZE);
767          return StreamSupport.doubleStream
768              (new RandomDoublesSpliterator
769               (this, 0L, streamSize, Double.MAX_VALUE, 0.0),
# Line 806 | Line 799 | public final class SplittableRandom {
799       * @return a stream of pseudorandom {@code double} values,
800       *         each with the given origin (inclusive) and bound (exclusive)
801       * @throws IllegalArgumentException if {@code streamSize} is
802 <     *         less than zero
810 <     * @throws IllegalArgumentException if {@code randomNumberOrigin}
802 >     *         less than zero, or {@code randomNumberOrigin}
803       *         is greater than or equal to {@code randomNumberBound}
804       */
805      public DoubleStream doubles(long streamSize, double randomNumberOrigin,
806                                  double randomNumberBound) {
807          if (streamSize < 0L)
808 <            throw new IllegalArgumentException(BadSize);
808 >            throw new IllegalArgumentException(BAD_SIZE);
809          if (!(randomNumberOrigin < randomNumberBound))
810 <            throw new IllegalArgumentException(BadRange);
810 >            throw new IllegalArgumentException(BAD_RANGE);
811          return StreamSupport.doubleStream
812              (new RandomDoublesSpliterator
813               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 839 | Line 831 | public final class SplittableRandom {
831       */
832      public DoubleStream doubles(double randomNumberOrigin, double randomNumberBound) {
833          if (!(randomNumberOrigin < randomNumberBound))
834 <            throw new IllegalArgumentException(BadRange);
834 >            throw new IllegalArgumentException(BAD_RANGE);
835          return StreamSupport.doubleStream
836              (new RandomDoublesSpliterator
837               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 854 | Line 846 | public final class SplittableRandom {
846       * approach. The long and double versions of this class are
847       * identical except for types.
848       */
849 <    static final class RandomIntsSpliterator implements Spliterator.OfInt {
849 >    private static final class RandomIntsSpliterator
850 >            implements Spliterator.OfInt {
851          final SplittableRandom rng;
852          long index;
853          final long fence;
# Line 909 | Line 902 | public final class SplittableRandom {
902      /**
903       * Spliterator for long streams.
904       */
905 <    static final class RandomLongsSpliterator implements Spliterator.OfLong {
905 >    private static final class RandomLongsSpliterator
906 >            implements Spliterator.OfLong {
907          final SplittableRandom rng;
908          long index;
909          final long fence;
# Line 965 | Line 959 | public final class SplittableRandom {
959      /**
960       * Spliterator for double streams.
961       */
962 <    static final class RandomDoublesSpliterator implements Spliterator.OfDouble {
962 >    private static final class RandomDoublesSpliterator
963 >            implements Spliterator.OfDouble {
964          final SplittableRandom rng;
965          long index;
966          final long fence;

Diff Legend

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