多线程随机数

小灰灰 2021-05-12 11:55 437阅读 0赞

**Random类及其局限性**

在JDK7之前java.util.Random是使用比较广泛的随机数生成工具类，另外java.lang.Math中的随机数生成也是使用的java.util.Random的实例。下面先看看java.util.Random的使用：

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

*  代码（1）创建一个默认随机数生成器，使用默认的种子。
 *  代码（2）输出输出10个在0-5（包含0，不包含5）之间的随机数。

这里提下随机数的生成需要一个默认的种子，种子其实是一个long类型的数字，这个种子要么在Random的时候通过构造函数指定，那么默认构造函数内部会生成一个默认的值，有了默认的种子后，如何生成随机数那？

public int nextInt(int bound) {
            //(3)参数检查
            if (bound <= 0)
                throw new IllegalArgumentException(BadBound);
            //(4)根据老的种子生成新的种子
            int r = next(31);
            //(5)根据新的种子计算随机数
            ...
            return r;
        }

如上代码可知新的随机数的生成需要两个步骤

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

在单线程情况下每次调用nextInt都是根据老的种子计算出来新的种子，这是可以保证随机数产生的随机性的。但是在多线程下多个线程可能都拿同一个老的种子去执行步骤（4）计算新的种子，这会导致多个线程产生的新种子是一样的，由于步骤（5）算法是固定的，所以会导致多个线程产生相同的随机值，这并不是我们想要的。所以步骤（4）要保证原子性，也就是说多个线程在根据同一个老种子计算新种子时候，第一个线程的新种子计算出来后，第二个线程要丢弃自己老的种子，要使用第一个线程的新种子来计算自己的新种子，依次类推，只有保证了这个，才能保证多线程下产生的随机数是随机的。Random函数使用一个原子变量达到了这个效果，在创建Random对象时候初始化的种子就保存到了种子原子变量里面，下面看下next()代码：

protected int next(int bits) {
            long oldseed, nextseed;
            AtomicLong seed = this.seed;
            do {
                //(6)
                oldseed = seed.get();
                //(7)
                nextseed = (oldseed * multiplier + addend) & mask;
                //(8)
            } while (!seed.compareAndSet(oldseed, nextseed));
            //(9)
            return (int)(nextseed >>> (48 - bits));
        }

*  代码（6）获取当前原子变量种子的值
 *  代码（7）根据当前种子值计算新的种子
 *  代码（8）使用CAS操作，用新的种子去更新老的种子，多线程下可能多个线程都同时执行到了代码（6）那么可能多个线程都拿到的当前种子的值是同一个，然后执行步骤（7）计算的新种子也都是一样的，但是步骤（8）的CAS操作会保证只有一个线程可以更新老的种子为新的，失败的线程会通过循环从新获取更新后的种子作为当前种子去计算老的种子，可见这里解决了上面提到的问题，也就保证了随机数的随机性。
 *  代码（9）则使用固定算法根据新的种子计算随机数。

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

**ThreadLocalRandom**

为了解决多线程高并发下Random的缺陷，JUC包下新增了ThreadLocalRandom类。

public class RandomTest {
    
        public static void main(String[] args) {
            //(10)获取一个随机数生成器
            ThreadLocalRandom random =  ThreadLocalRandom.current();
            
            //(11)输出10个在0-5（包含0，不包含5）之间的随机数
            for (int i = 0; i < 10; ++i) {
                System.out.println(random.nextInt(5));
            }
        }
    }

从名字看会让我们联想ThreadLocal，ThreadLocal的出现就是为了解决多线程访问一个变量时候需要进行同步的问题，让每一个线程拷贝一份变量，每个线程对变量进行操作时候实际是操作自己本地内存里面的拷贝，从而避免了对共享变量进行同步。实际上ThreadLocalRandom的实现也是这个原理，Random的缺点是多个线程会使用原子性种子变量，会导致对原子变量更新的竞争，如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXhpYW83MjM4NDY_size_16_color_FFFFFF_t_70][]

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXhpYW83MjM4NDY_size_16_color_FFFFFF_t_70 1][]

ThreadLocalRandom中并没有具体存放种子，具体的种子是存放到具体的调用线程的threadLocalRandomSeed变量里面的。当线程调用ThreadLocalRandom的current方法时候ThreadLocalRandom负责初始化调用线程的threadLocalRandomSeed变量，也就是初始化种子。当调用ThreadLocalRandom的nextInt方法时候，实际上是获取当前线程的threadLocalRandomSeed变量作为当前种子来计算新的种子，然后更新新的种子到当前线程的threadLocalRandomSeed变量，然后在根据新种子和具体算法计算随机数。

**注**：在ssh架构中，无论是Random、ThreadLocalRandom，都不能放在全局变量中定义，都应该放到方法中去定义、初始化。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXhpYW83MjM4NDY_size_16_color_FFFFFF_t_70]: /images/20210511/d368e82932f1464aacfd159c8fa0de63.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXhpYW83MjM4NDY_size_16_color_FFFFFF_t_70 1]: /images/20210511/43cfaba835cd4b0b8d6754796109fccc.png