第3章 Java并发包中ThreadLocalRandom类原理剖析

雨点打透心脏的1/2处 2023-03-13 06:56 16阅读 0赞

#### 3.1 Random类及其局限性 ####

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

*  首先根据老的种子生成新的种子。
 *  然后根据新的种子来计算新的随机数。

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

#### 3.2 ThreadLocalRandom ####

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

Random的缺点是多个线程会使用同一个原子性种子变量，从而导致对原子变量更新的竞争，如下图所示  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjkzMTUw_size_16_color_FFFFFF_t_70]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjkzMTUw_size_16_color_FFFFFF_t_70 1]

#### 3.3 源码分析 ####

**ThreadLocalRandom类中并没有使用继承自Random类的原子性种子变量。在ThreadLocalRandom中并没有存放具体的种子，具体的种子存放在具体的调用线程的threadLocalRandomSeed变量里面。** ThreadLocalRandom类似于ThreadLocal类，就是个工具类。**当线程调用ThreadLocalRandom的current方法时，ThreadLocalRandom负责初始化调用线程的threadLocalRandomSeed变量，也就是初始化种子。**

当调用ThreadLocalRandom的nextInt方法时，实际上是获取当前线程的threadLocalRandomSeed变量作为当前种子来计算新的种子，然后更新新的种子到当前线程的threadLocalRandomSeed变量，而后再根据新种子并使用具体算法计算随机数。

其中seeder和probeGenerator是两个原子性变量，在初始化调用线程的种子和探针变量时会用到它们，每个线程只会使用一次。变量instance是ThreadLocalRandom的一个实例，该变量是static的。当多线程通过ThreadLocalRandom的current方法获取ThreadLocalRandom的实例时，其实获取的是同一个实例。但是由于具体的种子是存放在线程里面的，所以在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实例
        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);
      }
    }

// ThreadLocalRandom current()方法
    public static ThreadLocalRandom current() {
        
      // (1)
      if (UNSAFE.getInt(Thread.currentThread(), PROBE) == 0)
        // (2)
        localInit();
      // (3)
      return instance;
    }
    
    static final void localInit() {
        
      int p = probeGenerator.addAndGet(PROBE_INCREMENT);
      int probe = (p == 0) ? 1 : p; // skip 0
      long seed = mix64(seeder.getAndAdd(SEEDER_INCREMENT));
      Thread t = Thread.currentThread();
      UNSAFE.putLong(t, SEED, seed);
      UNSAFE.putInt(t, PROBE, probe);
    }

在如上代码（1）中，如果当前线程中threadLocalRandomProbe的变量值为0（默认情况下线程的这个变量值为0），则说明当前线程是第一次调用ThreadLocalRandom的current方法，那么就需要调用localInit方法计算当前线程的初始化种子变量。这里为了延迟初始化，在不需要使用随机数功能时就不初始化Thread类中的种子变量，这是一种优化。代码（2）首先根据probeGenerator计算当前线程中threadLocalRandomProbe的初始化值，然后根据seeder计算当前线程的初始化种子，而后把这两个变量设置到当前线程。代码（3）返回ThreadLocalRandom的实例。需要注意的是，这个方法是静态方法，多个线程返回的是同一个ThreadLocalRandom实例。

// 该方法代码逻辑步骤与Random类nextInt()方法相似
    public int nextInt(int bound) {
        
      // (1)参数校验
      if (bound <= 0)
        throw new IllegalArgumentException(BadBound);
      // (2)根据当前线程中的种子计算新种子
      int r = mix32(nextSeed());
      // (3)根据新种子和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;
    }
    
    /**
     * 首先使用r = UNSAFE.getLong（t, SEED）获取当前线程中threadLocalRandomSeed变量的值，然后在
     * 种子的基础上累加GAMMA值作为新种子，而后使用UNSAFE的putLong方法把新种子放入当前线程的 	
     * threadLocalRandomSeed变量中。
     */
    final long nextSeed() {
        
      Thread t; long r; // read and update per-thread seed
      UNSAFE.putLong(t = Thread.currentThread(), SEED,
                     r = UNSAFE.getLong(t, SEED) + GAMMA);
      return r;
    }

#### 3.4 总结 ####

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjkzMTUw_size_16_color_FFFFFF_t_70]: /images/20230312/4aa9139acc244fe38f44e51f677e239a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjkzMTUw_size_16_color_FFFFFF_t_70 1]: /images/20230312/39e80efa4c2b4415a76736fdeca78130.png