ThreadLocalRandom

来源：互联网发布：台达plc编程教学视频编辑：程序博客网时间：2024/06/16 01:23

private static final ThreadLocal localRandom =
        new ThreadLocal() {
            protected ThreadLocalRandom initialValue() {
                return new ThreadLocalRandom();
            }
    };

    ThreadLocalRandom() {
        super();
        initialized = true;
    }


    public static ThreadLocalRandom current() {
        return localRandom.get();
    }

采用ThreadLocal进行包装的Random子类，每线程对应一个ThreadLocalRandom实例。测试代码：

@Test
 public void testInstance() {
  final ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
  final List randomList = new ArrayList();
  final Phaser barrier = new Phaser(1);
  
  new Thread() {
   @Override
   public void run() {
    randomList.add(ThreadLocalRandom.current());
    barrier.arrive();
   }
  }.start();

  barrier.awaitAdvance(barrier.getPhase());
  if (randomList.isEmpty()) {
   throw new NullPointerException();
  }

  Assert.assertTrue(threadLocalRandom != randomList.get(0));
 }

这么一包装，在性能上可以赶超Math.random()，不错。

@Test
 public void testSpeed() {
  final int MAX = 100000;
  ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();

  long start = System.nanoTime();
  for (int i = 0; i < MAX; i++) {
   threadLocalRandom.nextDouble();
  }
  long end = System.nanoTime() - start;
  System.out.println("use time1 : " + end);

  long start2 = System.nanoTime();
  for (int i = 0; i < MAX; i++) {
   Math.random();
  }
  long end2 = System.nanoTime() - start2;
  System.out.println("use time2 : " + end2);

  Assert.assertTrue(end2 > end);
 }

非规范的性能测试，某次输出结果:

use time1 : 3878481
use time2 : 8633080

性能差别不止两倍啊，哈哈。
再看Math.random()，其生成也是依赖于Random类:

private static Random randomNumberGenerator;

    private static synchronized void initRNG() {
        if (randomNumberGenerator == null) 
            randomNumberGenerator = new Random();
    }

    public static double random() {
        if (randomNumberGenerator == null) initRNG();
        return randomNumberGenerator.nextDouble();
    }

很奇怪，性能为什么差那么远呢？可能个各自的next函数不同造成。看一下Random中的next(int bits)方法实现：

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

而ThreadLocalRandom的重写版本为：

protected int next(int bits) {  
        rnd = (rnd * multiplier + addend) & mask;  
        return (int) (rnd >>> (48-bits));  
    }

相比ThreadLocalRandom的next(int bits)函数实现上更为简练，不存在seed的CAS(compare and set)操作，并且少了很多的运算量。
更为详细的机制研读，请阅读参考资料中链接。

另外，ThreadLocalRandom 也提供了易用的，两个数字之间的随机数生成方式。类似于：

nextDouble(double least, double bound)
nextInt(int least, int bound)
nextLong(long least, long bound)

随机数的生成范围为最小值 <= 随机数 < 最大值。可以包含最小值，但不包含最大值。

@Test
public void testHowtoUse(){
final ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
final int MAX = 100;
int result = threadLocalRandom.nextInt(0, 100);
Assert.assertTrue(MAX > result);
}
完全可以使用ThreadLocalRandom替代Random，尤其是在并发、并行、多任务等环境下，会比在多线程环境下
使用公共共享的Random对象实例更为有效。

1 0