【Java】随机数原理 Random ThreadLocalRandom

本文主要是介绍【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方法生成新随机数。
 

这篇关于【Java】随机数原理 Random ThreadLocalRandom的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---