java.util.Random 源码解析

最新推荐文章于 2024-02-17 23:16:41 发布

amyacker

最新推荐文章于 2024-02-17 23:16:41 发布

阅读量231

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.youkuaiyun.com/amyacker/article/details/103855537

版权

Java 专栏收录该内容

12 篇文章

订阅专栏

本文主要探讨了Java的Random类，详细解读了其源码，揭示了它如何实现线程安全，以及由于依赖原子类和CAS在多线程环境下的并发性能问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言

java.util.Random的源码阅读

介绍

java.util.Random是Java的一个实用工具类库中的一个类，提供了产生各种类型随机数的方法

// 无参构造方法
public Random() {
    // 生成种子 seedUniquifier方法和System.nanoTime()时间进行 异或运算
    this(seedUniquifier() ^ System.nanoTime());
}

// 初始的种子
private static final AtomicLong seedUniquifier = new AtomicLong(8682522807148012L);
private static long seedUniquifier() {
    // 多线程可以会赋值失败，所以使用for循环
    for (;;) {
        // 当前预期值
        long current = seedUniquifier.get();
        // 要更新的值
        long next = current * 181783497276652981L;
        // 使用CAS操作更新seedUniquifier
        if (seedUniquifier.compareAndSet(current, next))
            return next;
    }
}

private final AtomicLong seed;
// 有参构造方法
public Random(long seed) {
    if (getClass() == Random.class)
        this.seed = new AtomicLong(initialScramble(seed));
    else {
        // 子类可以重写setSeed()方法 
        this.seed = new AtomicLong();
        setSeed(seed);
    }
}

private static final long multiplier = 0x5DEECE66DL;
private static final long mask = (1L << 48) - 1;

// 把用户设置的种子进行运算 返回long
private static long initialScramble(long seed) {
    return (seed ^ multiplier) & mask;
}

synchronized public void setSeed(long seed) {
    this.seed.set(initialScramble(seed));
    haveNextNextGaussian = false;
}

public int nextInt(int bound) {
    // 判断 bound
    if (bound <= 0)
        throw new IllegalArgumentException(BadBound);
    // 根据旧种子生成新种子
    int r = next(31);
    // 下面这些代码都是根据新种子计算随机数
    int m = bound - 1;
    if ((bound & m) == 0) 
        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 {
        // 获取旧种子
        oldseed = seed.get();
        // 用旧种子去生成新种子
        nextseed = (oldseed * multiplier + addend) & mask;
    // 使用CAS，多线程下只能有一个线程更新为新种子，
    // 其他线程只能通过循环重新获取更新后的种子作为当前种子去计算新的种子
    } while (!seed.compareAndSet(oldseed, nextseed));
    return (int)(nextseed >>> (48 - bits));
}