「踩坑记录」ThreadLocalRandom 的正确使用

问题引入

  之前在《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)，这样才能初始化每个线程的种子，才可以起到随机数的效果。