Java中ThreadLocalRandom类原理剖析

朱雀 2023-01-05 12:39 156阅读 0赞

### 1、概述 ###

ThreadLocalRandom类是JDK7在JUC包下新增的随机数生成器，它弥补了Random类在多线程下的缺陷。

### 2、Random类及其局限性 ###

// java.util.Random的使用方法
    public class RandomTest {
        public static void main(String[] args) {
            // 创建一个默认种子的随机数生成器
            Random random = new Random();
            // 输出10个在0-5（包含0，不包含5）之间的随机数
            for (int i=0;i<10;++i) {
                System.out.println(random.nextInt(5));
            }
        }
    }

随机数的生成需要一个默认的种子，这个种子其实是一个long类型的数字，你可以在创建Random对象时通过构造函数指定，如果不指定则在默认构造函数内部生成一个默认的值。

**nextInt(int bound)源码如下：**

public int nextInt(int bound) {
            // 参数检查
            if (bound <= 0)
                throw new IllegalArgumentException(BadBound);
            // 根据老种子生成新种子
            int r = next(31);
            // 根据新种子计算随机数
            int m = bound - 1;
            if ((bound & m) == 0)  // i.e., bound is a power of 2
                r = (int)((bound * (long)r) >> 31);
            else {
                for (int u = r;
                     u - (r = u % bound) + m < 0;
                     u = next(31))
                    ;
            }
            return r;
        }

每个Random实例里面都有一个原子性的种子变量用来记录当前的种子值，当要生成新的随机数时需要根据当前种子计算新的种子并更新回原子变量。在多线程下使用单个Random实例生成随机数时，当多个线程同时计算随机数来计算新的种子时，多个线程会竞争同一个原子变量的更新操作，由于原子变量的更新是CAS操作，同时只有一个线程会成功，所以会造成大量线程进行自旋重试，这会降低并发性能，所以ThreadLocalRandom应运而生。

### 3、ThreadLocalRandom类 ###

为了弥补多线程高并发情况下Random的缺陷，在JUC包下新增了ThreadLocalRandom类。

### 3.1、ThreadLocalRandom类用法 ###

public class ThreadLocalRandomTest {
        public static void main(String[] args) {
            // 获取一个随机数生成器
            // 获取当前线程的随机数生成器
            ThreadLocalRandom random = ThreadLocalRandom.current();
    
            // 输出10个在0-5之间的随机数
            for (int i=0;i<10;i++) {
                System.out.println(random.nextInt(5));
            }
        }
    }

*  调用ThreadLocalRandom.current()来获取当前线程的随机数生成器。

ThreadLocalRandom使每个线程都维护一个种子变量，则每个线程生成随机数时都根据自己的老的种子计算新的种子，并使用新种子更新老种子，再根据新种子计算随机数，就不会存在竞争问题了，这回大大提高并发性能。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70][]

### 3.2、源码分析 ###

**ThreadLocalRandom的类图结构:**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70 1][]

从图中可以看出ThreadLocalRandom类继承了Random类并重写了nextInt方法，在ThreadLocalRandom类中并没有使用继承自Random类的原子性种子变量。在ThreadLocalRandom中并没有存放具体的种子，具体的种子存放在具体的调用线程的threadLocalRandomSeed变量里面。

当调用ThreadLocalRandom的nextInt方法时，实际上时获取当前线程的threadLocalRandomSeed变量作为当前种子来计算新的种子，然后更新新的种子到当前线程的threadLocalRandomSeed变量，而后再根据新种子并使用具体算法计算随机数。这里需要注意的是，threadLocalRandomSeed变量就是Thread类里面的一个普通long变量，它并不是原子性变量。其实道理很简单，因为这个变量是线程级别的，所以根本不需要使用原子性变量。

### 3.3、ThreadLocalRandom实现机制 ###

**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 = 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实例里的偏移量
                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() {
            if (UNSAFE.getInt(Thread.currentThread(), PROBE) == 0)		//如果当前线程的threadLocalRandomProbe变量为0，进行初始化
                localInit();
            return instance;
        }
    
    	static final void localInit() {
            int p = probeGenerator.addAndGet(PROBE_INCREMENT);
            int probe = (p == 0) ? 1 : p; // skip 0  ，不让PROBE变量为0
            long seed = mix64(seeder.getAndAdd(SEEDER_INCREMENT));
            Thread t = Thread.currentThread();
            UNSAFE.putLong(t, SEED, seed);		//初始化当前线程的threadLocalRandomSeed变量
            UNSAFE.putInt(t, PROBE, probe);		//初始化当前线程的threadLocalRandomProbe变量
        }

**int nextInt(int bound)方法**

计算当前线程的下一个随机数

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)
                    ;
            }
            return r;
        }

### 4、总结 ###

ThreadLocalRandom使用ThreadLocal的原理，让每个线程都持有一个本地变量的种子变量，该种子变量只有再使用随机数时才会被初始化。在多线程下计算新种子时时根据自己线程内维护的种子变量进行更新，从而避免了竞争。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70]: /images/20221119/88b764cea6fa4e439b0646e03da6a27f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210112162520311.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g=,size_16,color_FFFFFF,t_70