文章目录
- 1.Random类的局限性
- 2.ThreadLocalRandom
- 3.源码分析
- Unsafe机制
- current()方法
- int nextInt(int bound)方法
1.Random类的局限性
在JDK之前包括现在,java.util.Random都是使用比较广泛的随机数生成工具类。
下面我们先来看一下Random的使用方法。
// 创建一个默认种子的随机数生成器
Random random = new Random();
// 输出10个在0~5(包含0不包含5)之间的随机数
for(int i = 0; i < 10; i++)
System.out.println(random.nextInt());
首先我们要知道随机数的生成需要一个种子,这个种子其实是一个Long类型的数字。
你可以在使用Random的构造函数的时候指定种子,也可以不指定使用默认的种子。
接下来我们再来看看有了种子以后如何生成随机数。
public int nextInt(int bound) {
// 参数检查
if (bound <= 0)
throw new IllegalArgumentException(BadBound);
// 根据老的种子生成新的种子
int r = next(31);
// 根据新的种子计算随机数
...
return r;
}
这段代码简而言之就是两个步骤:
- 首先根据旧的种子生成新的种子
- 根据新的种子生成随机数
如果是在单线程下,这样是没有毛病的。但是如果在多线程的情况下,问题就来了。
多线程情况下,多个线程拿着相同的种子去计算随机数,因为计算随机数的算法是固定的,所以这些拿到相同种子的线程会生成相同的随机数。这不是我们想看到的。所以生成种子的这一步要保证原子性!简单来说就是第一个线程生成新的种子以后,第二个线程就要丢弃旧的种子,根据第一个线程所生成的新种子计算自己的新种子。
所以在上面一段代码中的next()
方法中,官方解决办法是,使用原子类AtomicLong
中的CAS操作。
下面我们直接看代码
protected int next(int bits) {
long oldseed, nextseed;
AtomicLong seed = this.seed;
do {
// 获取当前原子变量的种子值
oldseed = seed.get();
// 根据旧的种子值计算新的种子值
nextseed = (oldseed * multiplier + addend) & mask;
// 使用CAS操作,保证更新种子的操作具有原子性。这样就只有一个线程可以更新种子值,其他线程只有等待上一线程更新完毕才能更新新的种子。
} while (!seed.compareAndSet(oldseed, nextseed));
//(9)
return (int)(nextseed >>> (48 - bits));
}
至此,问题就暴露出来了,更新种子这个过程,在多线程情况下,大量线程自旋重试,会降低并发性能!所以才有了本文的重点ThreadLocalRandom
。
2.ThreadLocalRandom
看一下如何始使用:
public class RandomTest {
public static void main(String[] args) {
// 获取一个随机数生成器
ThreadLocalRandom random = ThreadLocalRandom.current();
// 输出10个在0~5(包含0,不包含5)之间的随机数
for (int i = 0; i < 10; ++i) {
System.out.println(random.nextInt(5));
}
}
}
3.源码分析
首先看ThreadLocalRandom的类图结构
在 ThreadLocalRandom
中并没有存放具体的种子,具体的种子存放在具体的调用线程的 threadLocalRandomSeed
变量里面。ThreadLocalRandom
类似于 ThreadLocal
类,就是个工具类。当线程调用 ThreadLocalRandom
的 current
方法时,ThreadLocalRandom
负责初始化 调用线程的 threadLocalRandomSeed
变量,也就是初始化种子。
当调用ThreadLocalRandom
类中的nextInt
方法时,实际上就是获取当前线程中的threadLocalRandomSeed
变量来计算新的种子,然后将新的种子更新到当前线程的threadLocalRandomSeed
变量中。这里要注意threadLocalRandomSeed
是一个普通的Long类型的变量,因为这个变量是线程级别的,所以根本不需要使用原子性变量。
说到这里如果你不理解,可以看看我上一篇博客中关于ThreadLocal的原理。
Unsafe机制
private static final sun.misc.Unsafe UNSAFE; private static final long SEED;
private static final long PROBE;
private static final long SECONDARY;
static {
try {//获取unsafe实例
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class<?> tk = Thread.class;
//获取Thread类里面threadLocalRandomSeed变量在Thread实例里面的偏移量
SEED = UNSAFE.objectFieldOffset
(tk.getDeclaredField("threadLocalRandomSeed"));
//获取Thread类里面threadLocalRandomProbe变量在Thread实例里面的偏移量
PROBE = UNSAFE.objectFieldOffset(tk.getDeclaredField("threadLocalRandomProbe"));
//获取Thread类里面threadLocalRandomSecondarySeed变量在Thread实例里面的偏移
量,这个值在后面讲解LongAdder时会用到
SECONDARY = UNSAFE.objectFieldOffset
(tk.getDeclaredField("threadLocalRandomSecondarySeed"));
} catch (Exception e) {
throw new Error(e);
}
}
current()方法
该方法用于获取ThreadLocalRandom
实例,并初始化调用线程中threadLocalRandomSeed
和threadLocalRandomProbe
static final ThreadLocalRandom instance = new ThreadLocalRandom();
public static ThreadLocalRandom current() {
// 该方法首先会判断线程中的threadLocalRandomProbe是否为零(线程中这个值默认为零)
if (UNSAFE.getInt(Thread.currentThread(), PROBE) == 0)
// 如果为零,则说明线程是第一次调用该方法,那么就需要初始化当前线程的种子变量
localInit();
return instance;
}
static final void localInit() {
// 首先使用probeGenerator中的方法计算当前线程中threadLocalRandomProbe的值
int p = probeGenerator.addAndGet(PROBE_INCREMENT);
// skip 0
int probe = (p == 0) ? 1 : p;
// 计算当前线程的初始化种子
long seed = mix64(seeder.getAndAdd(SEEDER_INCREMENT));
// 获得当前执行线程
Thread t = Thread.currentThread();
// 把上面两个变量设置到当前线程
UNSAFE.putLong(t, SEED, seed);
UNSAFE.putInt(t, PROBE, probe);
}
这里为了延迟初始化,在不需要使用随机数功能时就不初始化 Thread 类中的种子变量,这是一种优化。
同时我们需要注意,这是一个静态方法,多个线程返回的是同一个ThreadLocalRandom
变量。
int nextInt(int bound)方法
public int nextInt(int bound) {
//参数校验
if (bound <= 0)
throw new IllegalArgumentException(BadBound);
//根据当前线程中的种子计算新种子
int r = mix32(nextSeed());
//根据新种子和bound计算随机数
int m = bound - 1;
if ((bound & m) == 0) // power of two
r &= m;
else { // reject over-represented candidates
for (int u = r >>> 1;
u + m - (r = u % bound) < 0;
u = mix32(nextSeed()) >>> 1);
}
return r;
}
final long nextSeed() {
Thread t; long r; //
UNSAFE.putLong(t = Thread.currentThread(),
SEED,r = UNSAFE.getLong(t, SEED) + GAMMA);
return r;
}
在如上代码中,首先使用r = UNSAFE.getLong(t, SEED)
获取当前线程中 threadLocalRandomSeed
变量的值,然后在种子的基础上累加 GAMMA 值作为新种子,而 后使用 UNSAFE 的 putLong
方法把新种子放入当前线程的 threadLocalRandomSeed
变量中。