问题引入
之前在《Java 并发编程之美》中学到 ThreadLocalRandom 的时候,自己去实验了一下,于是写出了下面的代码:
import java.util.concurrent.ThreadLocalRandom;
public class RandomStu {
// 初始化一个 ThreadLocalRandom 实例
private static ThreadLocalRandom TEST = ThreadLocalRandom.current();
public static void main(String[] args) {
// 多线程输出随机数程序
for(int i=0;i<4;++i){
new Thread(()->{
for(int j=0;j<5;++j) {
System.out.println(Thread.currentThread().getName()+"第"+j+"个:"+TEST.nextInt(1000));
}
},"thread"+i).start();
}
}
}
复制代码
运行之后发现根本就没有随机的效果,每个线程的输出都是一样的,并且不管运行多少次,每个轮次输出的数都不变,如下图:
之后作者去查阅了 ThreadLocalRandom 的源码,搞清楚了问题,本文即是对这一分析过程的记录。
ThreadLocalRandom 简介
ThreadLocalRandom 的思想和 ThreadLocal 类似,都是让每个线程自己保存一些变量,防止多线程的竞争。避免了原先的 Java.util.Random 类在多线程情况下,其它线程不断 CAS 自旋。它的具体原理,我就不在这里介绍了,大家可以去看《Java 并发编程之美》,或者这篇博客: Java 随机数生成原理与 ThreadLocalRandom 详解,本文主要记录自己的踩坑,填坑过程。
问题分析
出现了问题,并且产生随机数的直接方法就是 nextInt 方法,我自然直接去看了 nextInt 的源码:
public int nextInt(int bound) {
if (bound <= 0)
throw new IllegalArgumentException(BAD_BOUND);
int r = mix32(nextSeed());
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)
;
}
// 最后返回 r
return r;
}
复制代码
可以看到,进行了一系列计算,最后返回了r
,并且这些计算主要是依赖于m
也就是 bound - 1
和r
的值,这里m
的值是我们在调用 nextInt 时传入的,所以关键是每个线程调用 nextInt 时,此函数一进来r
的值应该每次都不一样才对。既然现在每次每个线程的序列都一样,就说明每个线程进来r
的值都一样,所以后续经过同样的计算,产生了同样的序列。
r
一进来的赋值语句为int r = mix32(nextSeed());
,自然的,我先去看了 mix32 方法:
private static int mix32(long z) {
z = (z ^ (z >>> 33)) * 0xff51afd7ed558ccdL;
return (int)(((z ^ (z >>> 33)) * 0xc4ceb9fe1a85ec53L) >>> 32);
}
复制代码
可见,还是依赖传进来的z
,自然的,我去看了看得到z
的语句,nextSeed 方法:
private static final Unsafe U = Unsafe.getUnsafe();
// 用 Unsafe 类得到线程对应 threadLocalRandomSeed 变量的地址
private static final long SEED
= U.objectFieldOffset(Thread.class, "threadLocalRandomSeed");
final long nextSeed() {
Thread t; long r; // read and update per-thread seed
// 设置此ThreadLocalRandom 变量的值并存入线程
U.putLong(t = Thread.currentThread(), SEED,
r = U.getLong(t, SEED) + GAMMA);
return r;
}
复制代码
可以看到,这个函数从每个线程拿到它对应的SEED
,将此SEED
加上一个预先定义的GAMMA
,将这个值传给 mix32 方法,继而得到r
的初始值,继而经过一系列计算,得到输出的随机数值。看来问题就是出在这了。这里用r = U.getLong(t, SEED) + GAMMA);
语句赋值r
。
如果看过 ThreadLocalRandom 的原理,就会知道,每个线程的种子初始值在调用ThreadLocalRandom.current();
时初始化,于是,我去重新看了看这个方法:
// instance 变量,饿汉型的单例模式
static final ThreadLocalRandom instance = new ThreadLocalRandom();
// 拿到每个线程对应的 threadLocalRandomProbe 的地址
private static final long PROBE
= U.objectFieldOffset(Thread.class, "threadLocalRandomProbe");
public static ThreadLocalRandom current() {
// 如果线程的 threadLocalRandomProbe 没被设置,进行 localInit
if (U.getInt(Thread.currentThread(), PROBE) == 0)
localInit();
// 线程第二次以及以后进来,直接 return
return instance;
}
复制代码
可见,ThreadLocalRandom.current( ) 会检查每个线程的 threadLocalRandomProbe 是否被设置,若无,调用 localInit:
// seeder 变量,类加载时初始化,
// 每次都递增,保证每个线程的初始种子不一样
private static final AtomicLong seeder
= new AtomicLong(mix64(System.currentTimeMillis()) ^
mix64(System.nanoTime()));
// 每个线程只进来一次
static final void localInit() {
int p = probeGenerator.addAndGet(PROBE_INCREMENT);
int probe = (p == 0) ? 1 : p; // skip 0
// 每个线程调用时,由于 seeder.getAndAdd(),每个线程初始化的种子都不一样
long seed = mix64(seeder.getAndAdd(SEEDER_INCREMENT));
Thread t = Thread.currentThread();
// 将计算出的 seed,probe 存入线程对象
U.putLong(t, SEED, seed);
U.putInt(t, PROBE, probe);
}
复制代码
这里,存入线程对象的probe
肯定是非 0 的,由于int probe = (p == 0) ? 1 : p;
,那么线程下次在调用ThreadLocalRandom.current();
,就会直接返回instance
,不难看出,这里是一个饿汉单例模式。在这里,每个线程的种子得以初始化。
发现原因
一遍流程走完,我就发现原因了,因为我是在一开始在 main 线程里调用了private static ThreadLocalRandom TEST = ThreadLocalRandom.current();
,接着各个线程共享此TEST
,调用TEST.nextInt(1000)
,导致每个线程的初始种子都没有被设置。于是在 nextSeed 方法里,取到的每个线程的r
的值都是确定的:
final long nextSeed() {
Thread t; long r; // read and update per-thread seed
U.putLong(t = Thread.currentThread(), SEED,
r = U.getLong(t, SEED) + GAMMA);
return r;
}
复制代码
在 nextSeed 里,走到r = U.getLong(t, SEED) + GAMMA
时,由于子线程根本没进行过 threadLocalRandomSeed
的设置,所以第一次每个线程的U.getLong(t, SEED)
取出来都是 0,我甚至都可以预测第一次之后,r
的值。GAMMA
被初始化为这样的一坨值:
我们找个网站转换为十进制:
可见,转为十进制是这样的一坨值:-7046029254386353131,接下来,我们打断点看一下,可以断定:每个线程的r
第一次肯定被设置为了 -7046029254386353131。为了便于观察,把内循环改为循环一次:
for(int j=0;j<1;++j) {
System.out.println(Thread.currentThread().getName()+"第"+j+"个:"+TEST.nextInt(1000));
}
复制代码
于是,豁然开朗了,在 main 线程调用了private static ThreadLocalRandom TEST = ThreadLocalRandom.current();
,导致只有 main 线程的种子被设置了,然而我们的多线程程序和 main 线程没有关系,主要靠 4 个子线程输出随机数。4 个子线程种子没有被初始化过,默认都是 0,每次输出都经过相同的计算,自然每次都输出同样的值,没有任何随机效果。
正确的写法
找到了错误所在,正确写法也呼之欲出了,子线程不要共享 main 线程的TEST
,要像下面这样调用 nextInt:
for(int j=0;j<10;++j) {
System.out.println(Thread.currentThread().getName()+"第"+j+"个:"+
ThreadLocalRandom.current().nextInt(1000));
}
复制代码
每个子线程都ThreadLocalRandom.current().nextInt(1000)
这样调用 nextInt,由于只有线程第一次才会调用 localInit 方法,第一次之后,threadLocalRandomProbe
肯定不为 0,也不用担心一直调用ThreadLocalRandom.current().nextInt(1000)
会影响什么性能。
单例模式的疑问
有人问了,从ThreadLocalRandom.current();
代码来看,instance
只会生成一次啊,那你在哪里调用ThreadLocalRandom.current().nextInt(1000)
又有什么区别?instance
确实只生成一次,之所以每个子线程都调用它,就是为了每个线程第一次调用它时,可以初始化本线程的种子,下面再调用,就是调用instance.nextInt
了,方法都是操作调用线程的内部变量,就相当于一个工具类,本身不存储什么东西。
总结
使用 ThreadLocalRandom,不能多个线程共享某线程返回的 ThreadLocalRandom 实例,需要每个线程分别调用ThreadLocalRandom.current().nextInt(1000)
,这样才能初始化每个线程的种子,才可以起到随机数的效果。
近期评论