场景

Java中使用JMH(Java Microbenchmark Harness 微基准测试框架)进行性能测试和优化：

Java中使用JMH(Java Microbenchmark Harness 微基准测试框架)进行性能测试和优化_java热点函数

参考以上性能测试工具的使用。

Java开发手册中有这样一条：

【推荐】避免 Random 实例被多线程使用，虽然共享该实例是线程安全的，但会因竞争同一 seed导致的性能下降。

说明：Random 实例包括 java.util.Random 的实例或者 Math.random()的方式。

正例：在 JDK7 之后，可以直接使用 API ThreadLocalRandom，而在 JDK7 之前，

需要编码保证每个线程持有一个单独的 Random 实例。

Java开发手册中-避免Random实例被多线程使用、多线程下Random与ThreadLoacalRandom性能对比_java

Math.random() 底层确实是使用 Random 类来实现的。

Math.random()在底层调用了java.util.Random类的nextDouble()方法。

Random类的核心在于其内部维护了一个种子(seed),这个种子是随机数生成算法的起点。

相同的种子会生成相同的随机数序列。在创建Random对象时，如果不提供种子，则默认使用

系统时间作为种子，因此每次创建新的Random对象时，由于系统时间的不同，生成的随机数序列

也会不同。

而Random 在多线程下会因为竞争种⼦（seed）而导致性能下降，而ThreadLocalRandom 则不会出现这种情况，

因此在多线程环境下 ThreadLocalRandom 的性能会比Random 好很多。

注：

实现

接下来我们来测试⼀下 ThreadLocalRandom 和 Random 性能差异，测试代码如下：

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;

//测试完成时间
@BenchmarkMode(Mode.AverageTime)
//设置统计结果的时间单位
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 2,time = 1,timeUnit = TimeUnit.SECONDS)
//测试次数和时间，参数同上
@Measurement(iterations = 5,time = 1,timeUnit = TimeUnit.SECONDS)
//fork一个线程,进行 fork 的次数，可用于类或者方法上。如果 fork 数是 2 的话，则 JMH 会 fork 出两个进程来进行测试。
@Fork(1)
//通过 State 可以指定一个对象的作用范围，JMH 根据 scope 来进行实例化和共享操作。@State 可以被继承使用，
//Scope.Thread：默认的 State，每个测试线程分配一个实例
@State(Scope.Thread)
public class ThreadLocalRandomTest {
    public static void main(String[] args) throws RunnerException {
        //启动基准测试
        Options options = new OptionsBuilder()
                .include(ThreadLocalRandomTest.class.getSimpleName())//要导入的测试类
                .build();
        new Runner(options).run();//执行测试
    }

    @Benchmark
    public void randomTest(){
        int count = 0;
        Random random = new Random();
        for (int i = 0; i < 1000; i++) {
            count += random.nextInt(10);
        }
    }

    @Benchmark
    public void threadLocalRandomTest(){
        int count = 0;
        ThreadLocalRandom localRandom = ThreadLocalRandom.current();
        for (int i = 0; i < 1000; i++) {
            count += localRandom.nextInt(10);
        }
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.

测试结果：

//Benchmark                                    Mode  Cnt      Score      Error  Units
//ThreadLocalRandomTest.randomTest             avgt    5  10221.461 ± 1329.015  ns/op
//ThreadLocalRandomTest.threadLocalRandomTest  avgt    5   2887.904 ±  472.645  ns/op
  • 1.
  • 2.
  • 3.

从上述结果可以看出ThreadLocalRandom的性能⽐Random的性能⼤约⾼ 3.5倍，

因此在多线程情况下要尽量使⽤ ThreadLocalRandom。