/**
 * Creates a new random number generator. This constructor sets
 * the seed of the random number generator to a value very likely
 * to be distinct from any other invocation of this constructor.
 */
public Random() {
    //System.nanoTime()返回正在運行的Java虛擬機的高分辨率時間源的當(dāng)前值，以納秒為單位。
    //這里會調(diào)用有參構(gòu)造函數(shù)
    this(seedUniquifier() ^ System.nanoTime());
}

private static long seedUniquifier() {
    // 線性同余生成元表  
    for (;;) {
        long current = seedUniquifier.get();
        long next = current * 181783497276652981L; 
        // 兩個很大的數(shù)相乘
        if (seedUniquifier.compareAndSet(current, next))
            // 這個比較并且交換CAS
            // 比較當(dāng)前工作內(nèi)存中的值和主內(nèi)存中的值，如果這個值是期望的，那么則執(zhí)行操作！
            //如果不是就一直循環(huán)！就是為了保證即使在多線程的環(huán)境中返回的也是不同的數(shù)
            return next;
    }
}
// atomic 這個是 juc 里面修飾的原子性的 long ，get方法說就是獲得這個構(gòu)造函數(shù)里面的值
 private static final AtomicLong seedUniquifier
        = new AtomicLong(8682522807148012L);

public Random(long seed) {
    if (getClass() == Random.class)
        this.seed = new AtomicLong(initialScramble(seed));
    else {
        // 子類可能重寫了這個不考慮
        this.seed = new AtomicLong(); // 創(chuàng)建一個新的AtomicLong，初始值為 0 
        setSeed(seed);
    }
}
    //清除nextGaussian()使用的haveNextNextGaussian 標(biāo)志，
    synchronized public void setSeed(long seed) {
        this.seed.set(initialScramble(seed));
        haveNextNextGaussian = false; 
     }
    private static long initialScramble(long seed) {
        return (seed ^ multiplier) & mask;
     }
  private static final long multiplier = 0x5DEECE66DL;
  // x & [(1L << 48)–1]與 x（mod 2^48）等價 取低位48位
  // 帶符號左移
  private static final long mask = (1L << 48) - 1;

//Long類型的隨機
//long類型在Java中總弄64bit，對next方法的返回值左移32作為long的高位，然后將next方法返回值作為低32位，作為long類型的隨機數(shù)。
//此處關(guān)鍵之處在于next方法
public long nextLong() {
    return ((long)(next(32)) << 32) + next(32);
}

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

// 一個java應(yīng)用只有一個實例
// ThreadLocalRandom對象通過ThreadLocalRandom.current()獲取，之后可以直接返回隨機數(shù)
static final ThreadLocalRandom instance = new ThreadLocalRandom();
//獲取ThreadLocalRandom對象實例
public static ThreadLocalRandom current() {
    if (UNSAFE.getInt(Thread.currentThread(), PROBE) == 0)
        localInit();
    return instance;
}

//會從 object 對象var1的內(nèi)存地址偏移var2后的位置讀取四個字節(jié)作為long型返回
public native long getLong(Object var1, long var2);
//可以將object對象var1的內(nèi)存地址偏移var2后的位置后四個字節(jié)設(shè)置為 var4
public native void putLong(Object var1, long var2, long var4);

// Unsafe mechanics
private static final sun.misc.Unsafe UNSAFE;
private static final long SEED;
private static final long PROBE;
private static final long SECONDARY;
static {
    try {
        UNSAFE = sun.misc.Unsafe.getUnsafe();
        Class<?> tk = Thread.class;
        SEED = UNSAFE.objectFieldOffset
            (tk.getDeclaredField("threadLocalRandomSeed"));
        PROBE = UNSAFE.objectFieldOffset
            (tk.getDeclaredField("threadLocalRandomProbe"));
        SECONDARY = UNSAFE.objectFieldOffset
            (tk.getDeclaredField("threadLocalRandomSecondarySeed"));
    } catch (Exception e) {
        throw new Error(e);
    }
}

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

public long nextLong() {
    return mix64(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;
}