【Java】随机数原理 Random ThreadLocalRandom

大致生成原理：随机数由seed经过一定的转换生成。需要提供初始seed。每一次生成随机数时，先由老seed生成新seed，再根据新seed生成新的随机数。由于算法是固定的，所以如果初始seed一样，那么生成的随机数序列就是一样的，这就是为什么Java的随机数要被叫做“伪随机数”。数学逻辑这里不展开。
主要实现类有两个Random以及ThreadLocalRandom。这两个都是线程安全的，区别在于解决并发生成新seed的方式不一样。Random是通过cas+自旋的方式，所以高并发场景下会有竞争，可能造成性能瓶颈。ThreadLocalRandom从名字就可以看出，使用了ThreadLocal的思想,每一个线程都有自己的seed,所以不存在竞争,在多线程场景下性能更好.下面看下具体实现:

Random：
首先看下Random的无参构造函数，提供了初始seed的生成逻辑：

private static final AtomicLong seedUniquifier = new AtomicLong(8682522807148012L);
public Random() {
    this(seedUniquifier() ^ System.nanoTime());
}

private static long seedUniquifier() {
    long current;
    long next;
    do {
        current = seedUniquifier.get();
        next = current * 1181783497276652981L;
    } while(!seedUniquifier.compareAndSet(current, next));

    return next;
}

public Random(long seed) {
    this.haveNextNextGaussian = false;
    if (this.getClass() == Random.class) {
        this.seed = new AtomicLong(initialScramble(seed));
    } else {
        this.seed = new AtomicLong();
        this.setSeed(seed);
    }

}

可以看到是通过seedUniquifier和System.nanoTime两个函数做位运算生成的。seedUniquifier这个函数应该是为了生成初始化的seed，该函数使用cas的方式生成一个quilifer。不同的Random实例都有不同的quilifer，quilifer是通过cas变换一个static的变量生成的。之后再调用一个有参的构造函数设置初始seed。
接下来看下nextInt函数：

private final AtomicLong seed;
protected int next(int bits) {
    AtomicLong seed = this.seed;

    long oldseed;
    long nextseed;
    do {
        oldseed = seed.get();
        nextseed = oldseed * 25214903917L + 11L & 281474976710655L;
    } while(!seed.compareAndSet(oldseed, nextseed));

    return (int)(nextseed >>> 48 - bits);
}

可以看到，这里是通过cas方式将老的seed生成一个新的seed，由于seed本身是一个成员变量，如果多线程并发生成，这里就会有竞争。生成好新的seed后，再通过位运算生成新的随机值。其他函数类似。

ThreadLocalRandom：
ThreadLocalRandom的构造函数是private的:

static final ThreadLocalRandom instance;
private ThreadLocalRandom() {
}

所以初始seed不能设置，由ThreadLocalRandom类提供。并且，ThreadLocalRandom类是单例模式。在调用其current方法时构造单例，这里首先通过PROBE变量看是否已经为当前thread初始化seed了，如果没有就走localInit逻辑：

static final void localInit() {
    int p = probeGenerator.addAndGet(-1640531527);
    int probe = p == 0 ? 1 : p;
    long seed = mix64(seeder.getAndAdd(-4942790177534073029L));
    Thread t = Thread.currentThread();
    U.putLong(t, SEED, seed);
    U.putInt(t, PROBE, probe);
}

public static ThreadLocalRandom current() {
    if (U.getInt(Thread.currentThread(), PROBE) == 0) {
        localInit();
    }

    return instance;
}

localInit方法会调用mix64方法生成初始seed，然后将seed放入thread实例的变量里，同时设置probe标记位。所以每一个thread都有自己的seed。这里的seed和probe是通过unsafe包里的方法直接设置的：

private static final Unsafe U;
private static final long SEED;
private static final long PROBE;

U = Unsafe.getUnsafe();
SEED = U.objectFieldOffset(Thread.class, "threadLocalRandomSeed");
PROBE = U.objectFieldOffset(Thread.class, "threadLocalRandomProbe");

在ThreadLocalRandom类里通过unsafe的方法获得了这两个实例变量的迁移量，这样就可以直接通过偏移量设置变量的值了。为什么是这种方式？还有待探究。

另外，Thread类里其实有这两个实例变量：

public class Thread implements Runnable {
    @Contended("tlr")
    long threadLocalRandomSeed;
    @Contended("tlr")
    int threadLocalRandomProbe;
    @Contended("tlr")
    int threadLocalRandomSecondarySeed;
}

再看下，生成int随机数的逻辑：

public int nextInt() {
    return mix32(this.nextSeed());
}

private static int mix32(long z) {
    z = (z ^ z >>> 33) * -49064778989728563L;
    return (int)((z ^ z >>> 33) * -4265267296055464877L >>> 32);
}
final long nextSeed() {
    Thread t;
    long r;
    U.putLong(t = Thread.currentThread(), SEED, r = U.getLong(t, SEED) + -7046029254386353131L);
    return r;
}

先调用了nextSeed方法生成新seed，由于seed是线程独有的，不需要再像Random那样cas了，直接计算并设置新的seed即可。新的seed是在老的seed的基础上加了一个偏移。然后随机数根据新的seed并调用mix32方法生成新随机数。