Random在高併發下的缺陷以及JUC對其的優化

CoderBear發表於2019-04-21

Random可以說是每個開發都知道,而且都用的很6的類,如果你說,你沒有用過Random,也不知道Random是什麼鬼,那麼你也不會來到這個技術型別的社群,也看不到我的部落格了。但並不是每個人都知道Random的原理,知道Random在高併發下的缺陷的人應該更少。這篇部落格,我就來分析下Random類在併發下的缺陷以及JUC對其的優化。

Random的原理及缺陷

    public static void main(String[] args) {
        Random random = new Random();
        System.out.println(random.nextInt(100));
    }
複製程式碼

在學習程式設計的時候,我一直對JDK開發人員很不解:為什麼產生隨機數的方法名是:“”nextXXX”?雖然我英語只停留“點頭yes,搖頭no,來是come,去是go” 的水平,但是我知道next是“下一個”的意思,如果我來命名,會命名為“create”,“generate”,這樣不是更“貼切”嗎?為什麼JDK開發人員會命名為“nextXXX”呢?難道是他們突然“詞窮”了,想不出什麼單詞了,所以乾脆隨便來一個?後來才知道,原來通過Random生成的隨機數,並不是真正的隨機,它有一個種子的概念,是根據種子值來計算【下一個】值的,如果種子值相同,那麼它生成出來的隨機數也必定相等,也就是“確定的輸入產生確定的輸出”。

如果你不信的話,我們可以來做一個實驗:

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            Random random = new Random(15);
            System.out.println(random.nextInt(100));
        }
    }
複製程式碼

Random類除了提供無參的構造方法以外,還提供了有參的構造方法,我們可以傳入int型別的引數,這個引數就被稱為“種子”,這樣“種子”就固定了,生成的隨機數也都是一樣了:

41
41
41
41
41
41
41
41
41
41
複製程式碼

讓我們簡單的看下nextInt的原始碼把,原始碼涉及到演算法,當然演算法不是本篇部落格討論的重點,我們可以把原始碼簡化成如下的樣子:

    public int nextInt(int bound) {
        if (bound <= 0)
            throw new IllegalArgumentException(BadBound);
        //1.根據老的種子生成新的種子
        int r = next(31);
        //2.根據新的種子計算隨機數
        ...
        return r;
    }
複製程式碼

首先是根據老的種子生成新的種子,然後是根據新的種子計算出隨機數,nextXXX的核心程式碼可以被簡化這兩步。 現在讓我們想一個問題,如果在高併發的情況下,有N個執行緒,同時執行到第一步:根據老的種子生成新的種子,獲得的種子不就一樣了嗎?由於第二步是根據新的種子來計算隨機數,這個演算法又是固定的,會產生什麼情況?N個執行緒最終獲得的隨機數不都一樣了嗎?顯然這不是我們想要的,所以JDK開發人員想到了這點,讓我們看看next方法裡面做了什麼:

    protected int next(int bits) {
        long oldseed, nextseed;//定義舊種子,下一個種子
        AtomicLong seed = this.seed;
        do {
            oldseed = seed.get();//獲得舊的種子值,賦值給oldseed 
            nextseed = (oldseed * multiplier + addend) & mask;//一個神祕的演算法
        } while (!seed.compareAndSet(oldseed, nextseed));//CAS,如果seed的值還是為oldseed,就用nextseed替換掉,並且返回true,退出while迴圈,如果已經不為oldseed了,就返回false,繼續迴圈
        return (int)(nextseed >>> (48 - bits));//一個神祕的演算法
    }
複製程式碼
  1. 定義了舊種子oldseed,下一個種子(新種子)nextseed。
  2. 獲得舊的種子的值,賦值給oldseed 。
  3. 一個神祕的演算法,計算出下一個種子(新種子)賦值給nextseed。
  4. 使用CAS操作,如果seed的值還是oldseed,就用nextseed替換掉,並且返回true,!true為false,退出while迴圈;如果seed的值已經不為oldseed了,就說明seed的值已經被替換過了,返回false,!false為true,繼續下一次while迴圈。
  5. 一個神祕的演算法,根據nextseed計算出隨機數,並且返回。

我們可以看到核心就在第四步,我再來更詳細的的描述下,首先要知道seed的型別:

 private final AtomicLong seed;
複製程式碼

seed的型別是AtomicLong,是一個原子操作類,可以保證原子性,seed.get就是獲得seed具體的值,seed就是我們所謂的種子,也就是種子值儲存在了原子變數裡面。 當有兩個執行緒同時進入到next方法,會發生如下的事情:

  1. 執行緒A,執行緒B同時拿到了seed的值,賦值給oldseed變數。
  2. 根據一個神祕的演算法,計算出nextseed為XXX。注意,既然這個演算法是固定的,那麼生成出來的nextseed也必定是固定的。
  3. 進入while迴圈: 3.1 執行緒A,利用CAS演算法,發現seed的值還是為oldseed,說明seed的值沒有被替換過,就把seed的值替換成第二步生成出來的nextseed,替換成功,返回true,!true為false,退出while迴圈。 3.2 執行緒B,利用CAS演算法,發現seed的值已經不為oldseed了,因為執行緒A已經把seed的值替換成了nextseed了啊,所以CAS失敗,只能再次迴圈。再次迴圈的時候, seed.get()就拿到了最新的種子值,再次根據一個神祕的演算法獲得了nextSeed,CAS成功,退出迴圈。

看起來一切很美好,其實不然,如果併發很高,會發生什麼?大量的執行緒都在進行while迴圈,這是相當佔用CPU的,所以JUC推出了ThreadLocalRandom來解決這個問題。

ThreadLocalRandom

首先,讓我們來看看ThreadLocalRandom的使用方法:

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
            System.out.println(threadLocalRandom.nextInt(100));
        }
    }
複製程式碼

可以看到使用方式發生了些許的改變,我們來看看ThreadLocalRandom核心程式碼的實現邏輯:

current

    public static ThreadLocalRandom current() {
        if (UNSAFE.getInt(Thread.currentThread(), PROBE) == 0)
            localInit();
        return instance;
    }
複製程式碼

有一點需要注意,由於current是一個靜態的方法,所以多次呼叫此方法,返回的ThreadLocalRandom物件是同一個。

如果當前執行緒的PROBE是0,說明是第一次呼叫current方法,那麼需要呼叫localInit方法,否則直接返回已經產生的例項。

localInit
    static final void localInit() {
        int p = probeGenerator.addAndGet(PROBE_INCREMENT);
        int probe = (p == 0) ? 1 : p; // skip 0
        long seed = mix64(seeder.getAndAdd(SEEDER_INCREMENT));
        Thread t = Thread.currentThread();
        UNSAFE.putLong(t, SEED, seed);
        UNSAFE.putInt(t, PROBE, probe);
    }
複製程式碼

首先初始化probe和seed,隨後呼叫UNSAFE類的方法,把probe和seed設定到當前的執行緒,這樣其他執行緒就拿不到了。

nextInt

    public int nextInt(int bound) {
        if (bound <= 0)
            throw new IllegalArgumentException(BadBound);
        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;
    }
複製程式碼

和Random類下的nextXXX方法的原理一樣,也是根據舊的種子生成新的種子,然後根據新的種子來生成隨機數,我們來看下nextSeed方法做了什麼:

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) 來獲得當前執行緒的SEED,隨後+上GAMMA來作為新的種子值,隨後將新的種子值放到當前執行緒中。

總結

本文首先簡單的分析了Random的實現原理,引出nextXXX方法在高併發下的缺陷:需要競爭種子原子變數。接著介紹了ThreadLocalRandom的使用方法以及原理,從類的命名,就可以看出實現原理類似於ThreadLocal,seed種子是儲存在每個執行緒中的,也是根據每個執行緒中的seed來計算新的種子的,這樣就避免了競爭的問題。

相關文章