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.31 by jsr166, Fri Feb 19 03:39:15 2016 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 227 | Line 225 | public final class SplittableRandom {
225      private static final AtomicLong defaultGen = new AtomicLong(initialSeed());
226  
227      private static long initialSeed() {
228 <        String pp = java.security.AccessController.doPrivileged(
229 <                new sun.security.action.GetPropertyAction(
230 <                        "java.util.secureRandomSeed"));
231 <        if (pp != null && pp.equalsIgnoreCase("true")) {
228 >        if (java.security.AccessController.doPrivileged(
229 >            new java.security.PrivilegedAction<Boolean>() {
230 >                public Boolean run() {
231 >                    return Boolean.getBoolean("java.util.secureRandomSeed");
232 >                }})) {
233              byte[] seedBytes = java.security.SecureRandom.getSeed(8);
234 <            long s = (long)(seedBytes[0]) & 0xffL;
234 >            long s = (long)seedBytes[0] & 0xffL;
235              for (int i = 1; i < 8; ++i)
236 <                s = (s << 8) | ((long)(seedBytes[i]) & 0xffL);
236 >                s = (s << 8) | ((long)seedBytes[i] & 0xffL);
237              return s;
238          }
239 <        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) {
266 <        }
267 <        return (h ^ mix64(System.currentTimeMillis()) ^
239 >        return (mix64(System.currentTimeMillis()) ^
240                  mix64(System.nanoTime()));
241      }
242  
243      // IllegalArgumentException messages
244 <    static final String BadBound = "bound must be positive";
245 <    static final String BadRange = "bound must be greater than origin";
246 <    static final String BadSize  = "size must be non-negative";
244 >    static final String BAD_BOUND = "bound must be positive";
245 >    static final String BAD_RANGE = "bound must be greater than origin";
246 >    static final String BAD_SIZE  = "size must be non-negative";
247  
248      /*
249       * Internal versions of nextX methods used by streams, as well as
# Line 445 | Line 417 | public final class SplittableRandom {
417       */
418      public int nextInt(int bound) {
419          if (bound <= 0)
420 <            throw new IllegalArgumentException(BadBound);
420 >            throw new IllegalArgumentException(BAD_BOUND);
421          // Specialize internalNextInt for origin 0
422          int r = mix32(nextSeed());
423          int m = bound - 1;
# Line 473 | Line 445 | public final class SplittableRandom {
445       */
446      public int nextInt(int origin, int bound) {
447          if (origin >= bound)
448 <            throw new IllegalArgumentException(BadRange);
448 >            throw new IllegalArgumentException(BAD_RANGE);
449          return internalNextInt(origin, bound);
450      }
451  
# Line 497 | Line 469 | public final class SplittableRandom {
469       */
470      public long nextLong(long bound) {
471          if (bound <= 0)
472 <            throw new IllegalArgumentException(BadBound);
472 >            throw new IllegalArgumentException(BAD_BOUND);
473          // Specialize internalNextLong for origin 0
474          long r = mix64(nextSeed());
475          long m = bound - 1;
# Line 525 | Line 497 | public final class SplittableRandom {
497       */
498      public long nextLong(long origin, long bound) {
499          if (origin >= bound)
500 <            throw new IllegalArgumentException(BadRange);
500 >            throw new IllegalArgumentException(BAD_RANGE);
501          return internalNextLong(origin, bound);
502      }
503  
# Line 551 | Line 523 | public final class SplittableRandom {
523       */
524      public double nextDouble(double bound) {
525          if (!(bound > 0.0))
526 <            throw new IllegalArgumentException(BadBound);
526 >            throw new IllegalArgumentException(BAD_BOUND);
527          double result = (mix64(nextSeed()) >>> 11) * DOUBLE_UNIT * bound;
528          return (result < bound) ?  result : // correct for rounding
529              Double.longBitsToDouble(Double.doubleToLongBits(bound) - 1);
# Line 570 | Line 542 | public final class SplittableRandom {
542       */
543      public double nextDouble(double origin, double bound) {
544          if (!(origin < bound))
545 <            throw new IllegalArgumentException(BadRange);
545 >            throw new IllegalArgumentException(BAD_RANGE);
546          return internalNextDouble(origin, bound);
547      }
548  
# Line 598 | Line 570 | public final class SplittableRandom {
570       */
571      public IntStream ints(long streamSize) {
572          if (streamSize < 0L)
573 <            throw new IllegalArgumentException(BadSize);
573 >            throw new IllegalArgumentException(BAD_SIZE);
574          return StreamSupport.intStream
575              (new RandomIntsSpliterator
576               (this, 0L, streamSize, Integer.MAX_VALUE, 0),
# Line 639 | Line 611 | public final class SplittableRandom {
611      public IntStream ints(long streamSize, int randomNumberOrigin,
612                            int randomNumberBound) {
613          if (streamSize < 0L)
614 <            throw new IllegalArgumentException(BadSize);
614 >            throw new IllegalArgumentException(BAD_SIZE);
615          if (randomNumberOrigin >= randomNumberBound)
616 <            throw new IllegalArgumentException(BadRange);
616 >            throw new IllegalArgumentException(BAD_RANGE);
617          return StreamSupport.intStream
618              (new RandomIntsSpliterator
619               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 665 | Line 637 | public final class SplittableRandom {
637       */
638      public IntStream ints(int randomNumberOrigin, int randomNumberBound) {
639          if (randomNumberOrigin >= randomNumberBound)
640 <            throw new IllegalArgumentException(BadRange);
640 >            throw new IllegalArgumentException(BAD_RANGE);
641          return StreamSupport.intStream
642              (new RandomIntsSpliterator
643               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 684 | Line 656 | public final class SplittableRandom {
656       */
657      public LongStream longs(long streamSize) {
658          if (streamSize < 0L)
659 <            throw new IllegalArgumentException(BadSize);
659 >            throw new IllegalArgumentException(BAD_SIZE);
660          return StreamSupport.longStream
661              (new RandomLongsSpliterator
662               (this, 0L, streamSize, Long.MAX_VALUE, 0L),
# Line 725 | Line 697 | public final class SplittableRandom {
697      public LongStream longs(long streamSize, long randomNumberOrigin,
698                              long randomNumberBound) {
699          if (streamSize < 0L)
700 <            throw new IllegalArgumentException(BadSize);
700 >            throw new IllegalArgumentException(BAD_SIZE);
701          if (randomNumberOrigin >= randomNumberBound)
702 <            throw new IllegalArgumentException(BadRange);
702 >            throw new IllegalArgumentException(BAD_RANGE);
703          return StreamSupport.longStream
704              (new RandomLongsSpliterator
705               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 751 | Line 723 | public final class SplittableRandom {
723       */
724      public LongStream longs(long randomNumberOrigin, long randomNumberBound) {
725          if (randomNumberOrigin >= randomNumberBound)
726 <            throw new IllegalArgumentException(BadRange);
726 >            throw new IllegalArgumentException(BAD_RANGE);
727          return StreamSupport.longStream
728              (new RandomLongsSpliterator
729               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 770 | Line 742 | public final class SplittableRandom {
742       */
743      public DoubleStream doubles(long streamSize) {
744          if (streamSize < 0L)
745 <            throw new IllegalArgumentException(BadSize);
745 >            throw new IllegalArgumentException(BAD_SIZE);
746          return StreamSupport.doubleStream
747              (new RandomDoublesSpliterator
748               (this, 0L, streamSize, Double.MAX_VALUE, 0.0),
# Line 813 | Line 785 | public final class SplittableRandom {
785      public DoubleStream doubles(long streamSize, double randomNumberOrigin,
786                                  double randomNumberBound) {
787          if (streamSize < 0L)
788 <            throw new IllegalArgumentException(BadSize);
788 >            throw new IllegalArgumentException(BAD_SIZE);
789          if (!(randomNumberOrigin < randomNumberBound))
790 <            throw new IllegalArgumentException(BadRange);
790 >            throw new IllegalArgumentException(BAD_RANGE);
791          return StreamSupport.doubleStream
792              (new RandomDoublesSpliterator
793               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 839 | Line 811 | public final class SplittableRandom {
811       */
812      public DoubleStream doubles(double randomNumberOrigin, double randomNumberBound) {
813          if (!(randomNumberOrigin < randomNumberBound))
814 <            throw new IllegalArgumentException(BadRange);
814 >            throw new IllegalArgumentException(BAD_RANGE);
815          return StreamSupport.doubleStream
816              (new RandomDoublesSpliterator
817               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 854 | Line 826 | public final class SplittableRandom {
826       * approach. The long and double versions of this class are
827       * identical except for types.
828       */
829 <    static final class RandomIntsSpliterator implements Spliterator.OfInt {
829 >    private static final class RandomIntsSpliterator
830 >            implements Spliterator.OfInt {
831          final SplittableRandom rng;
832          long index;
833          final long fence;
# Line 909 | Line 882 | public final class SplittableRandom {
882      /**
883       * Spliterator for long streams.
884       */
885 <    static final class RandomLongsSpliterator implements Spliterator.OfLong {
885 >    private static final class RandomLongsSpliterator
886 >            implements Spliterator.OfLong {
887          final SplittableRandom rng;
888          long index;
889          final long fence;
# Line 965 | Line 939 | public final class SplittableRandom {
939      /**
940       * Spliterator for double streams.
941       */
942 <    static final class RandomDoublesSpliterator implements Spliterator.OfDouble {
942 >    private static final class RandomDoublesSpliterator
943 >            implements Spliterator.OfDouble {
944          final SplittableRandom rng;
945          long index;
946          final long fence;

Diff Legend

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