Java Random源码分析

作者:一个理想主义的大兵
链接:https://www.jianshu.com/p/c9617d1e29a9
來源:简书

一、Random类的构造函数,官方文档如下:

1.无参的构造函数,源码如下:

/**
* Creates a new random number generator. This constructor sets
* the seed of the random number generator to a value very likely
* to be distinct from any other invocation of this constructor.
this(seedUniquifier() ^ System.nanoTime());
*/ public Random() {
}

其中seedUniquifier()函数,个人认为是产生一个随机数,System.nanoTime()函数返回一个纳秒级的时间值

(这个时间代表什么不重要,此函数多用来计算流逝的时间,精度很高,详见源码及参考资料),源码中定义分别如下: 
private static long seedUniquifier() {
   // L'Ecuyer, "Tables of Linear Congruential Generators of
   // Different Sizes and Good Lattice Structure", 1999
   for (;;) {
       long current = seedUniquifier.get();
       long next = current * 181783497276652981L;
     if (seedUniquifier.compareAndSet(current, next))
         return next;
    }
}
/**
     * Returns the current value of the running Java Virtual Machine's
     * high-resolution time source, in nanoseconds.
     *
     * <p>This method can only be used to measure elapsed time and is
     * not related to any other notion of system or wall-clock time.
     * The value returned represents nanoseconds since some fixed but
     * arbitrary <i>origin</i> time (perhaps in the future, so values
     * may be negative).  The same origin is used by all invocations of
     * this method in an instance of a Java virtual machine; other
     * virtual machine instances are likely to use a different origin.
     *
     * <p>This method provides nanosecond precision, but not necessarily
     * nanosecond resolution (that is, how frequently the value changes)
     * - no guarantees are made except that the resolution is at least as
     * good as that of {@link #currentTimeMillis()}.
     *
     * <p>Differences in successive calls that span greater than
     * approximately 292 years (2<sup>63</sup> nanoseconds) will not
     * correctly compute elapsed time due to numerical overflow.
     *
     * <p>The values returned by this method become meaningful only when
     * the difference between two such values, obtained within the same
     * instance of a Java virtual machine, is computed.
     *
     * <p> For example, to measure how long some code takes to execute:
     *  <pre> {@code
     * long startTime = System.nanoTime();
     * // ... the code being measured ...
     * long estimatedTime = System.nanoTime() - startTime;}</pre>
     *
     * <p>To compare two nanoTime values
     *  <pre> {@code
     * long t0 = System.nanoTime();
     * ...
     * long t1 = System.nanoTime();}</pre>
     *
     * one should use {@code t1 - t0 < 0}, not {@code t1 < t0},
     * because of the possibility of numerical overflow.
     *
     * @return the current value of the running Java Virtual Machine's
     *         high-resolution time source, in nanoseconds
     * @since 1.5
     */
    public static native long nanoTime();

注:其中nanoTime()函数,用native关键字修饰,由本地代码实现。

两者异或运算后,初始化类成员变量seed,此变量会成为随机函数的种子,所有的随机算法都由种子数算起,定义如下: 
/**
     * The internal state associated with this pseudorandom number generator.
     * (The specs for the methods in this class describe the ongoing
     * computation of this value.)
     */
    private final AtomicLong seed;

2.有参的构造函数,源码如下:

/**
     * Creates a new random number generator using a single {@code long} seed.
     * The seed is the initial value of the internal state of the pseudorandom
     * number generator which is maintained by method {@link #next}.
     *
     * <p>The invocation {@code new Random(seed)} is equivalent to:
     *  <pre> {@code
     * Random rnd = new Random();
     * rnd.setSeed(seed);}</pre>
     *
     * @param seed the initial seed
     * @see   #setSeed(long)
     */
    public Random(long seed) {
        if (getClass() == Random.class)
            this.seed = new AtomicLong(initialScramble(seed));
        else {
            // subclass might have overriden setSeed
            this.seed = new AtomicLong();
            setSeed(seed);
        }
    }

构造函数由传入的种子参数进行初始化,不难理解,值得注意的是,由同一个种子初始化的Random对象,相同次数调用时,产生的随机数相同。举例如下:

public static void main(String[] args) {
    Random random = new Random(47);
    for(int i = 0; i < 3; i++){
        System.out.print(random.nextInt(20) + " ");
    }
    System.out.println();
    Random randomII = new Random(47);
    for(int i = 0; i < 3; i++){
        System.out.print(randomII.nextInt(20)+ " ");
    }
}

输出如下:
18 15 13 
18 15 13

二、Java随机数原理

大多数语言实现伪随机数,均采用线性同余方程(linear congruential generator),详细内容参照「资料1」.
Java中使用的是48-bit的种子,然后调用线性同余方程,源码如下:

protected int next(int bits) {
    long oldseed, nextseed;
    AtomicLong seed = this.seed;
    do {
        oldseed = seed.get();
        nextseed = (oldseed * multiplier + addend) & mask; //此处为核心,线性同余方程的实现
    } while (!seed.compareAndSet(oldseed, nextseed));
    return (int)(nextseed >>> (48 - bits));
}

经常在随机数中调用的函数nextInt(),源码如下:

public int nextInt(int bound) {
    if (bound <= 0)
        throw new IllegalArgumentException(BadBound);

    int r = next(31);
    int m = bound - 1;
    if ((bound & m) == 0)  // i.e., bound is a power of 2
        r = (int)((bound * (long)r) >> 31);
    else {
        for (int u = r;
             u - (r = u % bound) + m < 0;
             u = next(31))
            ;
    }
    return r;
}

Java Random源码分析》有1个想法

发表评论

电子邮件地址不会被公开。 必填项已用*标注