Java并发编程之美读书笔记5-Java并发包中ThreadLocalRandom类原理剖析

清疚 2024-04-19 09:46 82阅读 0赞

### 文章目录 ###

*   *  1. Random类
     *  2. Random类源码分析
     *   *  2.1 构造函数部分
         *  2.2 随机生成数部分
         *  2.3 Random类问题分析
     *  3. ThreadLocalRandom类
     *  4. ThreadLocalRandom源码分析
     *   *  4.1 构造函数部分
         *  4.2 随机数的生成
         *  4.3 注意事项
     *  5. 性能测试
     *  6. 小结

## 1. Random类 ##

`Random`类常常用来获取某个随机数的生成，如下：

//1.获取一个int范围内的随机数
    new Random().nextInt();
    //2.获取一个指定范围为[0,5)之间的随机数
    new Random().nextInt(5);

但是看起来没有任何问题的同时，没想到却存在线程安全问题。

--------------------

## 2. Random类源码分析 ##

1.首先创建一个下面测试方法：

public class RandomTest { 
    
        public static void main(String[] args) { 
            //（1）获取一个随机生成数
            Random random = new Random();
    
            //（2）输出10个0-5之间的随机数
            for (int i=0; i<10; i++) { 
                System.out.println(random.nextInt(5));
            }
        }
    }

上面是一个简单的生成随机数的方法，分为两部分查看：构造函数部分、生成随机数部分。

### 2.1 构造函数部分 ###

设置一个断点，进入构造函数中：

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

在分析无参的`Random()`方法时，首先对于参数`seedUniquifier`

//创建了AtomicLong类型的变量，与Long类型相比，多了一个保证并发的原子性操作
    private static final AtomicLong seedUniquifier
        = new AtomicLong(8682522807148012L);

由于其中还调用了`seedUniquifier()`方法和`nanoTime()`，`System.nanoTime()`其实就是用来获取当前时间（但是不是以毫秒为单位，而是以纳秒为单位），具体可[参考资料][Link 1]

private static long seedUniquifier() { 
        for (;;) { 
            // 获取上面定义的那个原子性long变量
            long current = seedUniquifier.get();
            // 计算next
            long next = current * 181783497276652981L;
            // 进行一个CAS操作，设置seedUniquifier的值为next
            if (seedUniquifier.compareAndSet(current, next))
                return next;
        }
    }

执行完无参构造的函数后，该无参函数调用了有参构造函数。

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

在`initialScramble（）`方法中使用了一个产生随机数常用的`线性同余发生器`。有兴趣可以参考[这里][Link 2]。通过构造函数基本上就产生了一个种子（这里通常称为`old seed`）。

通过上面的内容，就完成了`Random`对象的创建工作。

### 2.2 随机生成数部分 ###

在主程序中调用了`random.nexInt(5)`，不妨进入该方法中。

![format_png 2][]

上面方法中，`int r = next(31)`用于获取一个31为int，首先不分析它的作用。然后在后面的工作就是一些求余数的工作，反正保证生成的随机数需要保证在`[0,5)`之间，具体细节可以[参考][Link 3]。接下来分析`next(31)`是什么？

![在这里插入图片描述][format_png 3]

上面代码中，首先获取生成`random`对象时的`old seed`。然后通过线性同于生成器产生一个`next seed`。然后又是一个`CAS操作`（如果之前保存的seed（也就是oldseed）和现在读取到的oldseed是相同的，那么用nextseed更新当前oldseed）,然后根据我们需要的bit位数返回。

问题：

（1）为什么传入的是`int(31)`,而不是`int(32)`?

首先获取 31 位的随机数，注意这里是 31 位，和上面 32 位不同，因为在 nextInt() 方法中可以获取到随机数可能是负数，而 nextInt(int bound) 规定只能获取到 \[0,bound) 之前的随机数，也就意味着必须是正数，预留一位符号位，所以只获取了31位。(不要想着使用取绝对值这样操作，会导致性能下降)

（2）上面方式如何产生的随机数？

我觉得这里的核心关键就是`CAS`操作，首先获取到`oldseed`,然后利用线性同余生成一个`nextseed`,当发现`oldseed`和Random类中保存的`seed`一致时，用`nextseed`去更新该`seed`。所以之后每次得到的`oldseed`和上一次不一样，从而导致后面的`nextseed`不一样。因而就是随机。

### 2.3 Random类问题分析 ###

在单线程下每次在调用`nextInt`时都是根据老种子生成新种子，这可以保证生成随机数，但是在多线程下，多个线程可能拿到相同`oldseed`，然后在调用`next(31)`时得到的结果是一样的，显然这不是我们想要的，所以这也是为和在`next(31)`中需要使用`CAS`来保证原子性。然而，`CAS` 相比加锁有一定的优势，但并不一定意味着高效。同时只有一个线程会成功，其他线程需要自旋重试，这会降低并发性能，如果需要改进，那就是使用`ThreadLocalRandom`类。

--------------------

## 3. ThreadLocalRandom类 ##

（1）基本使用说明

首先注意其位置是`java.util.concurrent`包下

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

（2）`ThreadLocalRandom`原理说明

其原理和`ThreadLocal`的原理一样，首先`ThreadLocalRandom`通过让每一个线程复制一份变量，使得在每个线程对变量进行操作时实际是操作自己本地内存里面的副本，从而避免 了对共享变量进行同步 。Random 的缺点是多个线程会使用同 一个原子性种子变量， 从而导致对原子变量更新的竞争。

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

--------------------

## 4. ThreadLocalRandom源码分析 ##

1.在ThreadLocalRandom类中使用了Unsafe机制。

// Unsafe mechanics
    private static final sun.misc.Unsafe UNSAFE;
    private static final long SEED;
    private static final long PROBE;
    private static final long SECONDARY;
    static { 
        try { 
            //1.获取Unsafe实例
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class<?> tk = Thread.class;
            //2.获取Thread类里面threadLocalRandomSeed变量在Thread实例里面的偏移量
            SEED = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("threadLocalRandomSeed"));
            //3.获取Thread类里面threadLocalRandomProbe变量在Thread实例里面的偏移量
            PROBE = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("threadLocalRandomProbe"));
            //4.获取Thread类里面threadLocalRandomSecondarySeed交量在Thread实例里面的偏移量，这个值在后面讲解LongAdder时会用到
            SECONDARY = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("threadLocalRandomSecondarySeed"));
        } catch (Exception e) { 
            throw new Error(e);
        }
    }

不知道对上面的三个值是否还有印象，这三个值是在`Thread`类中定义的。

public Thread{ 
        /** The current seed for a ThreadLocalRandom */
        @sun.misc.Contended("tlr")  //这个注解用来控制伪共享
        long threadLocalRandomSeed; // 用来控制随机数种子
    
        /** Probe hash value; nonzero if threadLocalRandomSeed initialized */
        @sun.misc.Contended("tlr")
        int threadLocalRandomProbe; // 用来控制初始化
    
        /** Secondary seed isolated from public ThreadLocalRandom sequence */
        @sun.misc.Contended("tlr")
        int threadLocalRandomSecondarySeed; // 二级种子
    }

### 4.1 构造函数部分 ###

2.首先使用断点查看构造方法

![在这里插入图片描述][format_png 4]

在构造方法中根据`PROBE`来判断是否需要初始化。

// 3.方法是静态的，所以多个线程返回的是同一个ThreadLocalrandom实例
    public static ThreadLocalRandom current() { 
        //1.如果当前线程中的threadLocalRandomProbe的变量值为0（默认情况下，线程的这个值为0）
        if (UNSAFE.getInt(Thread.currentThread(), PROBE) == 0)
            // 2.如果时，则说明当前线程是第一次调用ThreadLocalRandom的current方法，就需要调用localInit方法来计算当前线程的初始化种子变量
            localInit();
        return instance;
    }

注意：这里通过使用这个`if语句`判断，当不需要随机数功能时就不初始化Thread类中的种子变量。这是一种优化。

其中对于`localInit()`方法

static final void localInit() { 
        // 1.首先根据 probeGenerator 计算当前线程中 threadLocalRandomProbe 的初始化值
        int p = probeGenerator.addAndGet(PROBE_INCREMENT);
        // 2.得到probe
        int probe = (p == 0) ? 1 : p; // skip 0
        // 3.计算得到seed种子
        long seed = mix64(seeder.getAndAdd(SEEDER_INCREMENT));
        Thread t = Thread.currentThread();
        // 4。在当前线程中保存probe和seed
        UNSAFE.putLong(t, SEED, seed);
        UNSAFE.putInt(t, PROBE, probe);
    }

通过上面步骤就完成了对象`threadLocalRandom`的创建。

### 4.2 随机数的生成 ###

首先进入`nextInt(int bound)`方法中，发现其中调用了`mix32`和`nextSeed`方法

![format_png 5][]

在`nextSeed`方法中有：

final long nextSeed() { 
        Thread t; long r; // read and update per-thread seed
        // 首先获取threadLocalrandomSeed变量值为r，然后在这个基础上增加GAMMA作为新种子，然后使用putLong方法加入到当前线程的threadLocalRandomSeed变量中。
        UNSAFE.putLong(t = Thread.currentThread(), SEED,
                       r = UNSAFE.getLong(t, SEED) + GAMMA);
        return r;
    }

可以发现，由于使用每个线程都各自维护了seed，所以不需要CAS操作，通过利用线程之间的隔离，减小并发冲突。所以整体上性能强于`Random`类。

### 4.3 注意事项 ###

由于前面的构造函数可知，前面在构造方法处就已经生成了`seed`.所以如果对于下面的这种情况呢？

public class RandomTest2 { 
    
        public static void main(String[] args) { 
            //（1）获取一个随机生成数
            ThreadLocalRandom random = ThreadLocalRandom.current();
    
            //（2）输出10个0-5之间的随机数
            for (int i=0; i<10; i++) { 
                new Thread(new Runnable() { 
                    @Override
                    public void run() { 
                        System.out.println(random.nextInt(5));
                    }
                }).start();
            }
        }
    }

上面的代码将会生成10个线程，知识不同时执行。但是他们都共享同一个`random`，所以得到的结果将是同一结果。

【重点】

所以建议使用`ThreadLocalRandom.current().next(5)`来生成某个随机数。

--------------------

## 5. 性能测试 ##

为了更加方便比较`Random`和`ThreadLocalRandom`在多线程下性能比较，这里使用了[JMH][]。【注意】：在使用之前，先学习一下JMH是什么

首先由如下的代码：

// 预热和执行分别设置3次预热执行，每个1秒进行实际操作，单位为微秒
    @Warmup(iterations = 4, time = 1, timeUnit = TimeUnit.MICROSECONDS)
    @Measurement(iterations = 4, time =1, timeUnit = TimeUnit.MICROSECONDS)
    @Threads(10) // 设置进程数为10
    @Fork(1) // 只需要执行一遍
    @State(Scope.Benchmark)  // 工作线程共享变量内容
    public class RandomBenchmark { 
    
        Random random = new Random();
    
        @Benchmark
        @BenchmarkMode(Mode.AverageTime)
        @OutputTimeUnit(TimeUnit.MICROSECONDS)
        public int random() { 
            return random.nextInt();
        }
    
        @Benchmark
        @BenchmarkMode(Mode.AverageTime)
        @OutputTimeUnit(TimeUnit.MICROSECONDS)
        public int threadLocalRandom() { 
            return ThreadLocalRandom.current().nextInt();
        }
    
        public static void main(String[] args) throws RunnerException { 
            Options opt = new OptionsBuilder()
                    .include(RandomBenchmark.class.getSimpleName())
                    .result("E:/randombenchmark.json")
                    .resultFormat(ResultFormatType.JSON)
                    .build();
    
            new Runner(opt).run();
        }
        
    }

执行代码：

Benchmark                          Mode  Cnt  Score   Error  Units
    RandomBenchmark.random             avgt    4  1.153 ± 4.152  us/op
    RandomBenchmark.threadLocalRandom  avgt    4  0.116 ± 0.211  us/op

其中图形结果为：

![在这里插入图片描述][format_png 6]

可以发现，使用`ThreadLocalRandom`果然可以明显增强性能。

--------------------

## 6. 小结 ##

以上便是对`Random`和`ThreadLocalRandom`类的分析，其中以上知识点的学习参考了如下的内容，他们对于每一个知识点讲解同样细致，可以参考学习。

参考资料：

*  Java并发编程之美
 *  [Java并发29:ThreadLocalRandom学习笔记-随机数的三种使用方法][Java_29_ThreadLocalRandom_-]
 *  [徐靖峰-Java随机数探秘][Link 3]
 *  [Random源码解析][Link 2]
 *  [Java的nanoTime()][Link 1]
 *  [Java微基准测试工具JMH][JMH]

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL3hmbGptL2ltZy9tYXN0ZXIvSW1nLzIwMTkwOTE2MTQwNDI3LnBuZw?x-oss-process=image/format,png
[Link 1]: https://www.iteye.com/blog/somefuture-2404685
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL3hmbGptL2ltZy9tYXN0ZXIvSW1nLzIwMTkwOTE2MTQwNzIxLnBuZw?x-oss-process=image/format,png
[Link 2]: http://www.ideabuffer.cn/2017/06/23/Random%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90/
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL3hmbGptL2ltZy9tYXN0ZXIvSW1nLzIwMTkwOTE2MTQwOTE4LnBuZw?x-oss-process=image/format,png
[Link 3]: https://www.cnkirito.moe/java-random/
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL3hmbGptL2ltZy9tYXN0ZXIvSW1nLzIwMTkwOTE2MTUxNjM4LnBuZw?x-oss-process=image/format,png
[format_png 4]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL3hmbGptL2ltZy9tYXN0ZXIvSW1nLzIwMTkwOTE2MTYxNTM4LnBuZw?x-oss-process=image/format,png
[format_png 5]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL3hmbGptL2ltZy9tYXN0ZXIvSW1nLzIwMTkwOTE2MTY1NDE2LnBuZw?x-oss-process=image/format,png
[JMH]: https://blog.csdn.net/xiaofei__/article/details/100865004
[format_png 6]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL3hmbGptL2ltZy9tYXN0ZXIvSW1nLzIwMTkwOTE2MTgzNTIxLnBuZw?x-oss-process=image/format,png
[Java_29_ThreadLocalRandom_-]: https://blog.csdn.net/hanchao5272/article/details/79691746