Fork/Join模式(JSR166y)手記之ThreadLocalRandom

時間 2019-11-11

標籤 fork join 模式 jsr166y jsr 手記 threadlocalrandom 欄目 Apache 简体版

原文原文鏈接

ThreadLocalRandom是一個能夠獨立使用的、用於生成隨機數的類。繼承自Random，但性能超過Random，所謂「青出於藍而勝於藍」。其API所提供方法，很少，父類Random具備的，它也同樣具備。從代表看，是一個單例模式，其實否則：

private static final ThreadLocallocalRandom =
        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 ListrandomList = 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操做，而且少了不少的運算量。
更爲詳細的機制研讀，請閱讀參考資料中連接。

另外，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);
}

嗯，還有，不支持setSeed方法。

曾經JDK 7中，ThreadLocalRandom 存在隨機多個線程隨機數生成相同的bug，但最新版本中，已不存在，被修復了,能夠放心使用。從如今開始，徹底可使用ThreadLocalRandom替代Random，尤爲是在併發、並行、多任務等環境下，會比在多線程環境下使用公共共享的Random對象實例更爲有效。

代碼清單： java

package com.learn.jsry166y.demo.random;

import java.util.ArrayList;
import java.util.List;

import jsr166y.Phaser;
import jsr166y.ThreadLocalRandom;
import junit.framework.Assert;

import org.junit.Test;

/**
 * ThreadLocalRandom簡單測試
 * @author yongboy
 * @time 2012-2-2
 * @version 1.0
 */
public class RandomTest {

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

	// 判斷兩個線程之間所引用的ThreadLocalRandom實例是不同的
	@Test
	public void testInstance() {
		final ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
		final List<ThreadLocalRandom> randomList = new ArrayList<ThreadLocalRandom>();
		// CountDownLatch的用法
		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));
	}
	
	@Test
	public void testHowtoUse(){
		final ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
		final int MAX = 100;
		int result = threadLocalRandom.nextInt(0, 100);
		
		Assert.assertTrue(MAX > result);
	}
}

view raw RandomTest.java hosted with ❤ by GitHub

參考資料: