简介

  • 随机数字生成器

  • 生成的是伪随机数

    源码

    1. public class Random implements java.io.Serializable {
    3.   static final long serialVersionUID = 3905348978240129619L;
    5.   // 此处是一个 原子类 AtomicLong 种子
    6.   private final AtomicLong seed;
    8.   // 乘数
    9.   private static final long multiplier = 0x5DEECE66DL;
    10.   // 加数
    11.   private static final long addend = 0xBL;
    12.   // 
    13.   private static final long mask = (1L << 48) - 1;
    15.   private static final double DOUBLE_UNIT = 0x1.0p-53; // 1.0 / (1L << 53)
    17.   // IllegalArgumentException消息
    18.   static final String BadBound = "bound must be positive";
    19.   static final String BadRange = "bound must be greater than origin";
    20.   static final String BadSize  = "size must be non-negative";
    22.   // 无参构造器 调用另一个有参构造器 
    23.   public Random() {
    24.       this(seedUniquifier() ^ System.nanoTime());
    25.   }
    27.   // 种子统一符方法
    28.   private static long seedUniquifier() {
    29.       for (;;) {
    30.           long current = seedUniquifier.get();
    31.           long next = current * 181783497276652981L;
    32.           if (seedUniquifier.compareAndSet(current, next))
    33.               return next;
    34.       }
    35.   }
    37.   // 种子统一数据
    38.   private static final AtomicLong seedUniquifier
    39.       = new AtomicLong(8682522807148012L);
    41.   // 参数为种子长度的构造方法
    42.   public Random(long seed) {
    43.       if (getClass() == Random.class)
    44.           this.seed = new AtomicLong(initialScramble(seed));
    45.       else {
    46.           this.seed = new AtomicLong();
    47.           setSeed(seed);
    48.       }
    49.   }
    51.   private static long initialScramble(long seed) {
    52.       return (seed ^ multiplier) & mask;
    53.   }
    55.   // 设置此随机数生成器的使用单个种子long的种子。 
    56.   // 总承包setSeed是，它改变了这个随机数生成器对象的状态，
    57.   // 从而，如果它刚刚与参数创建是完全相同的状态seed的种子。 
    58.   // 该方法setSeed由类实现Random通过原子地更新所述种子
    59.   // (seed ^ 0x5DEECE66DL) & ((1L << 48) - 1) 并清除haveNextNextGaussian由已使用标记
    60.   synchronized public void setSeed(long seed) {
    61.       this.seed.set(initialScramble(seed));
    62.       haveNextNextGaussian = false;
    63.   }
    65.   // 产生一个伪随机数。 子类应覆盖这一点，因为这是使用的所有其他方法。
    66.   protected int next(int bits) {
    67.       long oldseed, nextseed;
    68.       AtomicLong seed = this.seed;
    69.       do {
    70.           oldseed = seed.get();
    71.           nextseed = (oldseed * multiplier + addend) & mask;
    72.       } while (!seed.compareAndSet(oldseed, nextseed));
    73.       return (int)(nextseed >>> (48 - bits));
    74.   }
    76.   // 生成随机字节并将它们放置到用户提供的字节数组。 产生的随机字节数等于字节数组的长度
    77.   public void nextBytes(byte[] bytes) {
    78.       for (int i = 0, len = bytes.length; i < len; )
    79.           for (int rnd = nextInt(),
    80.                n = Math.min(len - i, Integer.SIZE/Byte.SIZE);
    81.                n-- > 0; rnd >>= Byte.SIZE)
    82.               bytes[i++] = (byte)rnd;
    83.   }
    85.   // nextLong的形式使用通过LongStream Spliterators。 
    86.   // 如果原产地是大于约束，作为nextLong的无限形式，否则为界形式
    87.   final long internalNextLong(long origin, long bound) {
    88.       long r = nextLong();
    89.       if (origin < bound) {
    90.           long n = bound - origin, m = n - 1;
    91.           if ((n & m) == 0L)  // power of two
    92.               r = (r & m) + origin;
    93.           else if (n > 0L) {  // reject over-represented candidates
    94.               for (long u = r >>> 1;            // ensure nonnegative
    95.                    u + m - (r = u % n) < 0L;    // rejection check
    96.                    u = nextLong() >>> 1) // retry
    97.                   ;
    98.               r += origin;
    99.           }
    100.           else {              // range not representable as long
    101.               while (r < origin || r >= bound)
    102.                   r = nextLong();
    103.           }
    104.       }
    105.       return r;
    106.   }
    108.   // 返回伪随机值
    109.   final int internalNextInt(int origin, int bound) {
    110.       if (origin < bound) {
    111.           int n = bound - origin;
    112.           if (n > 0) {
    113.               return nextInt(n) + origin;
    114.           }
    115.           else {  // range not representable as int
    116.               int r;
    117.               do {
    118.                   r = nextInt();
    119.               } while (r < origin || r >= bound);
    120.               return r;
    121.           }
    122.       }
    123.       else {
    124.           return nextInt();
    125.       }
    126.   }
    128.   // 返回伪随机值
    129.   final double internalNextDouble(double origin, double bound) {
    130.       double r = nextDouble();
    131.       if (origin < bound) {
    132.           r = r * (bound - origin) + origin;
    133.           if (r >= bound) // correct for rounding
    134.               r = Double.longBitsToDouble(Double.doubleToLongBits(bound) - 1);
    135.       }
    136.       return r;
    137.   }
    139.   // 无参数的nextInt方法
    140.   public int nextInt() {
    141.       return next(32);
    142.   }
    144.   // 带有参数的 nextInt 方法，参数为界限
    145.   public int nextInt(int bound) {
    146.       if (bound <= 0)
    147.           throw new IllegalArgumentException(BadBound);
    149.       int r = next(31);
    150.       int m = bound - 1;
    151.       if ((bound & m) == 0)  // i.e., bound is a power of 2
    152.           r = (int)((bound * (long)r) >> 31);
    153.       else {
    154.           for (int u = r;
    155.                u - (r = u % bound) + m < 0;
    156.                u = next(31))
    157.               ;
    158.       }
    159.       return r;
    160.   }
    162.   // 返回下一个伪，均匀分布的long从该随机数生成器的序列值。 
    163.   // 总承包nextLong是一个long值伪随机地生成并返回
    164.   public long nextLong() {
    165.       // it's okay that the bottom word remains signed.
    166.       return ((long)(next(32)) << 32) + next(32);
    167.   }
    169.   // 返回均匀分布的boolean值
    170.   public boolean nextBoolean() {
    171.       return next(1) != 0;
    172.   }
    174.   // 返回均匀分布的 ，在[0.0,1.0)之间的float数
    175.   public float nextFloat() {
    176.       return next(24) / ((float)(1 << 24));
    177.   }
    179.   // 返回均匀分布的 ，在[0.0,1.0)之间的double数
    180.   public double nextDouble() {
    181.       return (((long)(next(26)) << 27) + next(27)) * DOUBLE_UNIT;
    182.   }
    184.   private double nextNextGaussian;
    185.   private boolean haveNextNextGaussian = false;
    187.   // 返回下一个伪高斯（“正常”）分布的double用平均值0.0和标准偏差1.0从该随机数生成器的序列。
    188.   synchronized public double nextGaussian() {
    189.       // See Knuth, ACP, Section 3.4.1 Algorithm C.
    190.       if (haveNextNextGaussian) {
    191.           haveNextNextGaussian = false;
    192.           return nextNextGaussian;
    193.       } else {
    194.           double v1, v2, s;
    195.           do {
    196.               v1 = 2 * nextDouble() - 1; // between -1 and 1
    197.               v2 = 2 * nextDouble() - 1; // between -1 and 1
    198.               s = v1 * v1 + v2 * v2;
    199.           } while (s >= 1 || s == 0);
    200.           double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s)/s);
    201.           nextNextGaussian = v2 * multiplier;
    202.           haveNextNextGaussian = true;
    203.           return v1 * multiplier;
    204.       }
    205.   }
    207.   // 返回产生所述给定流streamSize伪随机数int值。 
    208.   // 伪随机int ，如果是在调用该方法的结果生成的值nextInt()
    209.   public IntStream ints(long streamSize) {
    210.       if (streamSize < 0L)
    211.           throw new IllegalArgumentException(BadSize);
    212.       return StreamSupport.intStream
    213.           (new RandomIntsSpliterator
    214.            (this, 0L, streamSize, Integer.MAX_VALUE, 0),
    215.            false);
    216.   }
    218.   public IntStream ints() {
    219.       return StreamSupport.intStream
    220.           (new RandomIntsSpliterator
    221.            (this, 0L, Long.MAX_VALUE, Integer.MAX_VALUE, 0),
    222.            false);
    223.   }
    225.   public IntStream ints(long streamSize, int randomNumberOrigin,
    226.                         int randomNumberBound) {
    227.       if (streamSize < 0L)
    228.           throw new IllegalArgumentException(BadSize);
    229.       if (randomNumberOrigin >= randomNumberBound)
    230.           throw new IllegalArgumentException(BadRange);
    231.       return StreamSupport.intStream
    232.           (new RandomIntsSpliterator
    233.            (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
    234.            false);
    235.   }
    237.   public IntStream ints(int randomNumberOrigin, int randomNumberBound) {
    238.       if (randomNumberOrigin >= randomNumberBound)
    239.           throw new IllegalArgumentException(BadRange);
    240.       return StreamSupport.intStream
    241.           (new RandomIntsSpliterator
    242.            (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
    243.            false);
    244.   }
    246.   // 返回生产给定流streamSize伪随机数long值
    247.   public LongStream longs(long streamSize) {
    248.       if (streamSize < 0L)
    249.           throw new IllegalArgumentException(BadSize);
    250.       return StreamSupport.longStream
    251.           (new RandomLongsSpliterator
    252.            (this, 0L, streamSize, Long.MAX_VALUE, 0L),
    253.            false);
    254.   }
    256.   public LongStream longs() {
    257.       return StreamSupport.longStream
    258.           (new RandomLongsSpliterator
    259.            (this, 0L, Long.MAX_VALUE, Long.MAX_VALUE, 0L),
    260.            false);
    261.   }
    263.   public LongStream longs(long streamSize, long randomNumberOrigin,
    264.                           long randomNumberBound) {
    265.       if (streamSize < 0L)
    266.           throw new IllegalArgumentException(BadSize);
    267.       if (randomNumberOrigin >= randomNumberBound)
    268.           throw new IllegalArgumentException(BadRange);
    269.       return StreamSupport.longStream
    270.           (new RandomLongsSpliterator
    271.            (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
    272.            false);
    273.   }
    275.   public LongStream longs(long randomNumberOrigin, long randomNumberBound) {
    276.       if (randomNumberOrigin >= randomNumberBound)
    277.           throw new IllegalArgumentException(BadRange);
    278.       return StreamSupport.longStream
    279.           (new RandomLongsSpliterator
    280.            (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
    281.            false);
    282.   }
    284.   public DoubleStream doubles(long streamSize) {
    285.       if (streamSize < 0L)
    286.           throw new IllegalArgumentException(BadSize);
    287.       return StreamSupport.doubleStream
    288.           (new RandomDoublesSpliterator
    289.            (this, 0L, streamSize, Double.MAX_VALUE, 0.0),
    290.            false);
    291.   }
    293.   public DoubleStream doubles() {
    294.       return StreamSupport.doubleStream
    295.           (new RandomDoublesSpliterator
    296.            (this, 0L, Long.MAX_VALUE, Double.MAX_VALUE, 0.0),
    297.            false);
    298.   }
    300.   public DoubleStream doubles() {
    301.       return StreamSupport.doubleStream
    302.           (new RandomDoublesSpliterator
    303.            (this, 0L, Long.MAX_VALUE, Double.MAX_VALUE, 0.0),
    304.            false);
    305.   }
    307.   public DoubleStream doubles(double randomNumberOrigin, double randomNumberBound) {
    308.       if (!(randomNumberOrigin < randomNumberBound))
    309.           throw new IllegalArgumentException(BadRange);
    310.       return StreamSupport.doubleStream
    311.           (new RandomDoublesSpliterator
    312.            (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
    313.            false);
    314.   }
    316.   // 静态内部类 分流器
    317.   static final class RandomIntsSpliterator implements Spliterator.OfInt {
    318.       final Random rng;
    319.       long index;
    320.       final long fence;
    321.       final int origin;
    322.       final int bound;
    323.       RandomIntsSpliterator(Random rng, long index, long fence,
    324.                             int origin, int bound) {
    325.           this.rng = rng; this.index = index; this.fence = fence;
    326.           this.origin = origin; this.bound = bound;
    327.       }
    329.       public RandomIntsSpliterator trySplit() {
    330.           long i = index, m = (i + fence) >>> 1;
    331.           return (m <= i) ? null :
    332.           new RandomIntsSpliterator(rng, i, index = m, origin, bound);
    333.       }
    335.       public long estimateSize() {
    336.           return fence - index;
    337.       }
    339.       public int characteristics() {
    340.           return (Spliterator.SIZED | Spliterator.SUBSIZED |
    341.                   Spliterator.NONNULL | Spliterator.IMMUTABLE);
    342.       }
    344.       public boolean tryAdvance(IntConsumer consumer) {
    345.           if (consumer == null) throw new NullPointerException();
    346.           long i = index, f = fence;
    347.           if (i < f) {
    348.               consumer.accept(rng.internalNextInt(origin, bound));
    349.               index = i + 1;
    350.               return true;
    351.           }
    352.           return false;
    353.       }
    355.       public void forEachRemaining(IntConsumer consumer) {
    356.           if (consumer == null) throw new NullPointerException();
    357.           long i = index, f = fence;
    358.           if (i < f) {
    359.               index = f;
    360.               Random r = rng;
    361.               int o = origin, b = bound;
    362.               do {
    363.                   consumer.accept(r.internalNextInt(o, b));
    364.               } while (++i < f);
    365.           }
    366.       }
    367.   }
    369.   // 分词器
    370.   static final class RandomLongsSpliterator implements Spliterator.OfLong {
    371.       final Random rng;
    372.       long index;
    373.       final long fence;
    374.       final long origin;
    375.       final long bound;
    376.       RandomLongsSpliterator(Random rng, long index, long fence,
    377.                              long origin, long bound) {
    378.           this.rng = rng; this.index = index; this.fence = fence;
    379.           this.origin = origin; this.bound = bound;
    380.       }
    382.       public RandomLongsSpliterator trySplit() {
    383.           long i = index, m = (i + fence) >>> 1;
    384.           return (m <= i) ? null :
    385.           new RandomLongsSpliterator(rng, i, index = m, origin, bound);
    386.       }
    388.       public long estimateSize() {
    389.           return fence - index;
    390.       }
    392.       public int characteristics() {
    393.           return (Spliterator.SIZED | Spliterator.SUBSIZED |
    394.                   Spliterator.NONNULL | Spliterator.IMMUTABLE);
    395.       }
    397.       public boolean tryAdvance(LongConsumer consumer) {
    398.           if (consumer == null) throw new NullPointerException();
    399.           long i = index, f = fence;
    400.           if (i < f) {
    401.               consumer.accept(rng.internalNextLong(origin, bound));
    402.               index = i + 1;
    403.               return true;
    404.           }
    405.           return false;
    406.       }
    408.       public void forEachRemaining(LongConsumer consumer) {
    409.           if (consumer == null) throw new NullPointerException();
    410.           long i = index, f = fence;
    411.           if (i < f) {
    412.               index = f;
    413.               Random r = rng;
    414.               long o = origin, b = bound;
    415.               do {
    416.                   consumer.accept(r.internalNextLong(o, b));
    417.               } while (++i < f);
    418.           }
    419.       }
    420.   }
    422.   // 分词器
    423.   static final class RandomLongsSpliterator implements Spliterator.OfLong {
    424.       final Random rng;
    425.       long index;
    426.       final long fence;
    427.       final long origin;
    428.       final long bound;
    429.       RandomLongsSpliterator(Random rng, long index, long fence,
    430.                              long origin, long bound) {
    431.           this.rng = rng; this.index = index; this.fence = fence;
    432.           this.origin = origin; this.bound = bound;
    433.       }
    435.       public RandomLongsSpliterator trySplit() {
    436.           long i = index, m = (i + fence) >>> 1;
    437.           return (m <= i) ? null :
    438.           new RandomLongsSpliterator(rng, i, index = m, origin, bound);
    439.       }
    441.       public long estimateSize() {
    442.           return fence - index;
    443.       }
    445.       public int characteristics() {
    446.           return (Spliterator.SIZED | Spliterator.SUBSIZED |
    447.                   Spliterator.NONNULL | Spliterator.IMMUTABLE);
    448.       }
    450.       public boolean tryAdvance(LongConsumer consumer) {
    451.           if (consumer == null) throw new NullPointerException();
    452.           long i = index, f = fence;
    453.           if (i < f) {
    454.               consumer.accept(rng.internalNextLong(origin, bound));
    455.               index = i + 1;
    456.               return true;
    457.           }
    458.           return false;
    459.       }
    461.       public void forEachRemaining(LongConsumer consumer) {
    462.           if (consumer == null) throw new NullPointerException();
    463.           long i = index, f = fence;
    464.           if (i < f) {
    465.               index = f;
    466.               Random r = rng;
    467.               long o = origin, b = bound;
    468.               do {
    469.                   consumer.accept(r.internalNextLong(o, b));
    470.               } while (++i < f);
    471.           }
    472.       }
    474.   }
    476.   // 
    477.   static final class RandomDoublesSpliterator implements Spliterator.OfDouble {
    478.       final Random rng;
    479.       long index;
    480.       final long fence;
    481.       final double origin;
    482.       final double bound;
    483.       RandomDoublesSpliterator(Random rng, long index, long fence,
    484.                                double origin, double bound) {
    485.           this.rng = rng; this.index = index; this.fence = fence;
    486.           this.origin = origin; this.bound = bound;
    487.       }
    489.       public RandomDoublesSpliterator trySplit() {
    490.           long i = index, m = (i + fence) >>> 1;
    491.           return (m <= i) ? null :
    492.           new RandomDoublesSpliterator(rng, i, index = m, origin, bound);
    493.       }
    495.       public long estimateSize() {
    496.           return fence - index;
    497.       }
    499.       public int characteristics() {
    500.           return (Spliterator.SIZED | Spliterator.SUBSIZED |
    501.                   Spliterator.NONNULL | Spliterator.IMMUTABLE);
    502.       }
    504.       public boolean tryAdvance(DoubleConsumer consumer) {
    505.           if (consumer == null) throw new NullPointerException();
    506.           long i = index, f = fence;
    507.           if (i < f) {
    508.               consumer.accept(rng.internalNextDouble(origin, bound));
    509.               index = i + 1;
    510.               return true;
    511.           }
    512.           return false;
    513.       }
    515.       public void forEachRemaining(DoubleConsumer consumer) {
    516.           if (consumer == null) throw new NullPointerException();
    517.           long i = index, f = fence;
    518.           if (i < f) {
    519.               index = f;
    520.               Random r = rng;
    521.               double o = origin, b = bound;
    522.               do {
    523.                   consumer.accept(r.internalNextDouble(o, b));
    524.               } while (++i < f);
    525.           }
    526.       }
    527.   }
    529.   private static final ObjectStreamField[] serialPersistentFields = {
    530.       new ObjectStreamField("seed", Long.TYPE),
    531.       new ObjectStreamField("nextNextGaussian", Double.TYPE),
    532.       new ObjectStreamField("haveNextNextGaussian", Boolean.TYPE)
    533.   };
    535.   private void readObject(java.io.ObjectInputStream s)
    536.       throws java.io.IOException, ClassNotFoundException {
    538.       ObjectInputStream.GetField fields = s.readFields();
    540.       long seedVal = fields.get("seed", -1L);
    541.       if (seedVal < 0)
    542.           throw new java.io.StreamCorruptedException(
    543.           "Random: invalid seed");
    544.       resetSeed(seedVal);
    545.       nextNextGaussian = fields.get("nextNextGaussian", 0.0);
    546.       haveNextNextGaussian = fields.get("haveNextNextGaussian", false);
    547.   }
    549.   synchronized private void writeObject(ObjectOutputStream s)
    550.       throws IOException {
    552.       // set the values of the Serializable fields
    553.       ObjectOutputStream.PutField fields = s.putFields();
    555.       // The seed is serialized as a long for historical reasons.
    556.       fields.put("seed", seed.get());
    557.       fields.put("nextNextGaussian", nextNextGaussian);
    558.       fields.put("haveNextNextGaussian", haveNextNextGaussian);
    560.       // save them
    561.       s.writeFields();
    562.   }
    564.   private static final Unsafe unsafe = Unsafe.getUnsafe();
    565.   private static final long seedOffset;
    566.   static {
    567.       try {
    568.           seedOffset = unsafe.objectFieldOffset
    569.               (Random.class.getDeclaredField("seed"));
    570.       } catch (Exception ex) { throw new Error(ex); }
    571.   }
    572.   private void resetSeed(long seedVal) {
    573.       unsafe.putObjectVolatile(this, seedOffset, new AtomicLong(seedVal));
    574.   }
    575. }

    伪随机数

    public class RandomTest {
  public static void main(String[] args) {
      //只要两个Random对象的种子相同，而且方法的调用顺序也相同，产生的随机数相同         
      //Random产生的数字并不是真正随机的，而是一种伪随机         
      Random r1 = new Random(16);
      System.out.println("第一个种子为16的Random对象");
      System.out.println("r1.nextBoolean() =  " + r1.nextBoolean());
      System.out.println("r1.nextInt() =      " + r1.nextInt());
      System.out.println("r1.nextDouble() =   " + r1.nextDouble());
      System.out.println("r1.nextGaussian() = " + r1.nextGaussian());
      System.out.println("-------------------------------------------------------");
  }
}

  • 多次的执行结果如下 ```java 第一个种子为16的Random对象 r1.nextBoolean() = true r1.nextInt() = -2031839431 r1.nextDouble() = 0.527826082540034 r1.nextGaussian() = 0.014363412537037566

```

  • 因为其执行的结果都一样，所以称之为伪随机数

    总结

  • 在上面的分析中，我没有过多的去解释代码的作用

  • Random中用到了 AtomicLong 类。最后返回 (int)(nextseed >>> (48 - bits))
  • 核心算法是next(int bits) 在其方法内部执行了CAS计算
  • 同时也用到了高斯分布