Java中的Random和ThreadLocalRandom详细解析

/**
 * 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虚拟机的高分辨率时间源的当前值，以纳秒为单位。
    //这里会调用有参构造函数
    this(seedUniquifier() ^ System.nanoTime());
}

private static long seedUniquifier() {
    // 线性同余生成元表  
    for (;;) {
        long current = seedUniquifier.get();
        long next = current * 181783497276652981L; 
        // 两个很大的数相乘
        if (seedUniquifier.compareAndSet(current, next))
            // 这个比较并且交换CAS
            // 比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作！
            //如果不是就一直循环！就是为了保证即使在多线程的环境中返回的也是不同的数
            return next;
    }
}
// atomic 这个是 juc 里面修饰的原子性的 long ，get方法说就是获得这个构造函数里面的值
 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(); // 创建一个新的AtomicLong，初始值为 0 
        setSeed(seed);
    }
}
    //清除nextGaussian()使用的haveNextNextGaussian 标志，
    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类型的随机数。
//此处关键之处在于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应用只有一个实例
// ThreadLocalRandom对象通过ThreadLocalRandom.current()获取，之后可以直接返回随机数
static final ThreadLocalRandom instance = new ThreadLocalRandom();
//获取ThreadLocalRandom对象实例
public static ThreadLocalRandom current() {
    if (UNSAFE.getInt(Thread.currentThread(), PROBE) == 0)
        localInit();
    return instance;
}

//会从 object 对象var1的内存地址偏移var2后的位置读取四个字节作为long型返回
public native long getLong(Object var1, long var2);
//可以将object对象var1的内存地址偏移var2后的位置后四个字节设置为 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;
}