[[428387]]

本文轉載自微信公眾號「一個程序員的成長」，作者一個程序員的成長。轉載本文請聯系一個程序員的成長公眾號。

1、Random類及其局限性

public int nextInt(int bound) { 
    if (bound <= 0) 
        throw new IllegalArgumentException(BadBound); 
    // 計算新的種子 
    int r = next(31); 
    int m = bound - 1; 
    // 根據新的種子計算隨機數 
    if ((bound & m) == 0)  // i.e., bound is a power of 2 
        r = (int)((bound * (long)r) >> 31); 
    else { 
        for (int u = r; 
             u - (r = u % bound) + m < 0; 
             u = next(31)) 
            ; 
    } 
    return r; 
} 

protected int next(int bits) { 
    long oldseed, nextseed; 
    // 這是一個原子性的變量 
    AtomicLong seed = this.seed; 
    do { 
        // (1)、獲取老的種子 
        oldseed = seed.get(); 
        // (2)、計算出新的種子 
        nextseed = (oldseed * multiplier + addend) & mask; 
    // (3)、CAS操作更新老的種子 
    } while (!seed.compareAndSet(oldseed, nextseed)); 
    return (int)(nextseed >>> (48 - bits)); 
} 

Random小結：

• 面試：多線程下Random存在什么樣的問題?

每個Random實例里面都有一個原子性的種子變量用來記錄當前的種子值，當要生成新的隨機數時需要根據當前的種子計算新的種子并更新種子變量。當在多線程環境下，多個線程會競爭同一個原子變量的更新操作，由于原子變量的更新時CAS操作，同時只有一個線程會成功，所以會造成大量線程進行自旋重試，從而降低并發性能。

可能出現的癥狀：如果并發請求非常多，自旋鎖一直重試，那么CPU會一直飆升。

2、ThreadLocalRandom

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

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

這個方法用來創建ThreadLocalRandom隨機數生成器，如果當前線程中threadLocalRandomProbe的變量值為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); 
} 

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

mix32是一個固定的算法，這里重點看下nextSeed方法，當第一次調用的時候進行初始化，獲取當前線程threadLocalRandomSeed的值(第一次默認值為0) + 種子增量，如果不是第一次那么獲取舊種子的值 + 種子增量生成新的種子變量并設置回去。這樣的話多線程環境下就避免了競爭，因為threadLocalRandomSeed是Thread的一個變量，屬于線程級別。