ThreadLocalRandom与Random效率对比

ThreadLocalRandom类是jdk1.7在juc包下新增的随机数生成器，该类继承于Random类，那既然有Random随机数生成器了，为什么在jdk1.7的时候又新增一个呢？，这是因为Random在多线程坏境下的效率并不理想，在多线程下使用存在局限性，所以为了提高多线程坏境下随机数生成的效率引入从而了ThreadLocalRandom类。

我们先来一个例子来对比下这两个类效率。

@State(Scope.Benchmark)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 5, time = 1)
@Fork(1)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
public class TestMain {

    private ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
    private Random random = new Random();

    public static void main(String[] args) throws RunnerException {
        Options options = new OptionsBuilder().include(TestMain.class.getName()).build();

        new Runner(options).run();
    }

    @Benchmark
    @Threads(8)
    public void runThreadLocalRandom() {
        for (int i = 0; i < 1000; i++) {
            threadLocalRandom.nextInt();
        }
    }

    @Benchmark
    @Threads(8)
    public void runRandom() {
        for (int i = 0; i < 1000; i++) {
            random.nextInt();
        }
    }
}

上面例子中所需要的包为jdk的jmh包，jmh是jdk出的一个基准测试框架，该框架最好的一个点我觉得是可以对方法进行预热，因为jit的存在，预热可以更加贴近真实线上坏境，感兴趣的同学可以去了解下jmh强大的功能。

maven引入方式：
<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-core</artifactId>
    <version>1.21</version>
</dependency>
<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-generator-annprocess</artifactId>
    <version>1.21</version>
</dependency>

输出结果如下：

当然结果可能存在小小的偏差，因为坏境以及硬件的不同都会对性能有所影响，但是也能够说明Random在多线程下的随机数生成效率是远低于ThreadLocalRandom的。

接下来我们来具体分析一下Random以及ThreadLocalRandom

1.Random类

random类的源码层级较为简单，其最主要的核心代码在next方法中

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

由源码我们来分析random生成随机数的逻辑，为了方便描述我把上面代码标记了行数，首先第一行代码是先获取老的种子值，获取到oldSeed之后进行代码2逻辑，计算新的种子值，得出新的种子值后进入代码3逻辑，将新的种子值替换为老种子值，这里采用的cas无锁方式进行。
这段代码单线程下是不会出现任何效率问题的，但是多线程下就有问题，假如同时有4个线程同时执行到了（1），然后获取到种子值后同时计算了新的种子值，这个时候进行代码3进行cas替换，代码3肯定只能允许一个线程通过，假如t1成功执行，这个时候其他三个线程就会再次进行1、2代码逻辑，这样就导致了性能的损耗。

2.ThreadLocalRandom类

ThreadLocalRandom类我们具体关注下nextSeed方法就行。

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;
    }

可以看出先调用了UNSAFE.getLong(t, SEED)来获取当前的变量值，然后加上一个增量值作为新种子并重新赋值给线程t，这里和ThreadLocal的原理类似，让每个线程都有自己单独的种子变量，避免了多线程的竞争关系，从而提高了随机数生成的效率。

总结：其实ThreadLocalRandom这种效率优化的方式在jdk中有很多类似的，就是尽可能的避免变量的竞争关系，就是竞争粒度细化，比如LongAdder类，他的优化的方式也是类似的，感兴趣的同学可以下去查看下LongAdder的源码，并去测试一下对比AtomicLong的性能是不是真的有所提升。