Java多线程（12）——ThreadLocalRandom源码剖析

最新推荐文章于 2023-02-26 18:25:59 发布

喵的波波鱼

最新推荐文章于 2023-02-26 18:25:59 发布

阅读量640

点赞数 1

分类专栏： # Java多线程

本文链接：https://blog.csdn.net/qq_34805255/article/details/102384212

版权

Java多线程专栏收录该内容

32 篇文章 2 订阅

订阅专栏

1.为什么JUC下要新增ThreadLocalRandom?

2.ThreadLocalRandom

2.1 ThreadLocalRandom使用示例

2.2 ThreadLocalRandom的源码分析

1.为什么JUC下要新增ThreadLocalRandom?

在jdk1.7之前，java.util.Random是使用比较广泛的随机数生成工具类，我们先来看个Random的案例：

package ThreadLocalRandom;

import java.util.Random;

public class RandomTest {
    public static void main(String[] args) {
        
        //1.创建随机数生成器
        Random random = new Random(5);
        //2.循环打印0-5之间的随机数
        for (int i = 0; i < 10; i++) {
            System.out.println(random.nextInt());
        }
    }
}

我们先来看上述代码内部做了什么？

当我们在创建随机数生成器的时候，会传入一个种子，这个种子实际是AtomicLong类型，
如果我们在创建Random对象的时候，没有通过构造函数去指定，它会根据当前的时间生成一个默认的种子

生成随机数的过程：

可以看到在生成随机数的过程中，仅仅做了两件事：

1.根据老种子计算新种子
2.根据新种子计算随机数

而上述两步骤都是具有固定的算法，也就是只要传入的老种子相同，它们最终计算的随机数的结果就相同

当多线程中，我们调用随机数的时候，我们一般都是想让每个线程生成的是不同随机数，但以上这种方式，只要多个线程同时都去操作相同的种子，它们就会计算出相同的结果，所以我们需要保证在计算新种子的过程的原子性，也就是当多个线程根据同一个老种子计算新种子时，只有一个线程能去执行修改，并且修改之后，第二个执行的线程必须获取到第一个线程修改后的结果，再去获得新种子，这样就能保证随机性

为了解决这个问题，Random类本身把种子seed定义为AtomicLong类型，并且在计算新种子的方法中使用了CAS+自旋来控制多个线程，同一时间，只能有一个线程进入do循环中，其他线程只能自旋，当一个线程进入到循环之后，它会首先获取seed的值，这也就保证了下一个线程先获得到上一个线程修改后的值，这样每个线程使用的种子就会不相同，得到不同的结果，从而实现随机性

分析上述方法的缺点：

可以发现上述方法会造成大量的线程进行自旋，这会降低并发的性能，所以在jdk1.7就引入了ThreadLocalRandom类

2.ThreadLocalRandom

上述问题是由于多个线程去操作一个共享资源种子seed引起的，而我们能不能让每个线程拥有自己的种子，这时，就可以想到的是ThreadLocal机制，让每个线程拥有自己的种子变量，这样就避免了多线程之间的竞争

2.1 ThreadLocalRandom使用示例

我们先使用一下ThreadLocalRandom，然后再一步一步分析ThreadLocalRandom源码的实现

package ThreadLocalRandom;

import java.util.concurrent.ThreadLocalRandom;

public class ThreadLocalRandomTest {
    public static void main(String[] args) {

        //1.创建随机数生成器
        ThreadLocalRandom random = ThreadLocalRandom.current();

        new Thread(()->{
            //2.循环打印0-5之间的随机数
            for (int i = 0; i < 5; i++) {
                System.out.println("线程A"+i+"\t"+random.nextInt(5));
            }
        },"A").start();

        new Thread(()->{
            //2.循环打印0-5之间的随机数
            for (int i = 0; i < 5; i++) {
                System.out.println("线程B"+i+"\t"+random.nextInt(5));
            }
        },"B").start();
    }

}

以上示例可以发现一个点，我们在使用ThreadRandom的时候，是通过它的current方法，为什么是这样会在下面得到解释

2.2 ThreadLocalRandom的源码分析

而ThreadLocalRandom的大致实现如下：

1.ThreadLocal虽然继承了Random，但并没有使用原子类型的种子变量，而是为每个线程定义自己的种子字段

在Thread类中可以找到如下三个字段，它们就是每个线程用于存放种子的字段：

所以当每个线程在创建的时候，就会拥有该三个字段

2.在我们主动使用ThreadLocalRandom（即调用静态方法current）的时候，会导致类的初始化，以下代码就会执行，通过Unsafe直接取到Thread类中这几个字段的偏移量

3.我们在创建ThreadLocalRandom对象的时候只能调用current方法，是因为它使用了单例模式，
- ThreadLocalRanddom类私有了构造方法，
- 提供了静态私有属性instance来在ThreadLocalRandom类初始化阶段通过new关键字来创建ThreadLocalRandom对象，
- 并且提供静态方法current让我们去获取ThreadLocalRandom该对象

4.在current方法中会先进行判断，获取到的是当前线程对象的字段的值，如果它为0，就代表没有初始化种子，就使用localInit()方法进行初始化

    /**
     * 初始化当前线程的 threadLocalRandomSeed 和 threadLocalRandomProbe 字段
     */
    static final void localInit() {
        //通过原子变量probeGenerator和seeder计算出两个值probe和seed
        int p = probeGenerator.addAndGet(PROBE_INCREMENT);
        int probe = (p == 0) ? 1 : p; // skip 0
        long seed = mix64(seeder.getAndAdd(SEEDER_INCREMENT));
        
        //将计算出的值分别对应赋值给当前线程的 threadLocalRandomSeed 和 threadLocalRandomProbe 字段
        Thread t = Thread.currentThread();
        UNSAFE.putLong(t, SEED, seed);
        UNSAFE.putInt(t, PROBE, probe);
    }

可以看到该初始化就是给当前线程的threadLocalRandomSeed 和 threadLocalRandomProbe 字段赋予初始值

说明：seeder和probeGenerator是两个原子变量，只有在这里使用来初始化调用线程的threadLocalRandomSeed 和 threadLocalRandomProbe字段，每个线程只会使用一次

5.然后当我们每次调用nextInt方法的时候，会首先调用nextSeed来计算新的种子

    public int nextInt(int bound) {
        //范围检查
        if (bound <= 0)
            throw new IllegalArgumentException(BadBound);
        //nextSeed方法会计算出新的种子
        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;
    }

    final long nextSeed() {
        Thread t; long r; // read and update per-thread seed
        //获取当前线程对象的threadLocalRandomSeed字段的值，并对它进行增加GAMMA,然后写回该字段
        UNSAFE.putLong(t = Thread.currentThread(), SEED,
                r = UNSAFE.getLong(t, SEED) + GAMMA);
        //返回增加后的该种子值
        return r;
    }

所以通过以上可以看出，ThreadLocalRandom的实现中，将种子作为线程对象的字段，与每个线程相关联，所以每个线程都有自己的种子，这与ThreadLocal的思想是一样的，都是在线程类Thread中增加字段，即让该字段与线程对象绑定，然后在每次通过方法写入获取的时候，都是访问当前线程的对象的该字段的值，
从而在多线程中，由于它们是各自线程的私有数据，就不存在多个线程操作共享资源的问题，就不会引发竞争，更不会引发线程安全问题

特别说明：

1.Thread类的种子变量threadLocalRandomSeed是long类型的，并非原子性变量，这是因为，这个变量是线程私有的，所以并不会存在多个线程去操作此变量的问题
2.ThreadLocalRandom的instance为什么没有使用volatile去修饰保证线程安全？
- 因为该类是单例的，多个线程获取到的是同一个实例，然后，具体的种子存放在线程里面，所以在ThreadLocalRandom的实例当中只包含与线程无关的通用算法，所以它是线程安全的
3.在当我们调用current方法的时候设置localInit方法进行初始化其实也是进行了优化，我们知道每个Thread都会有种子字段，但是在我们大多数使用线程的时候，根本不会用ThreadLocalRandom，所以就没必要初始化该几个字段，所以此处设置localInit方法只在我们要使用ThreadLocalRandom的时候才去初始化Thread中的threadLocalRandomSeed 和 threadLocalRandomProbe 字段