一、核心概念与使用场景

1. 基本定义

AtomicReference<Double> 是 Java java.util.concurrent.atomic 包下的原子类，用于在多线程环境下，对 Double 包装类对象引用进行原子性的读取、修改和更新操作。

2. 核心作用

保证多线程环境下 Double 类型数据操作的线程安全，避免使用 synchronized 关键字带来的锁竞争开销，同时防止普通 Double 变量在多线程下出现的赋值覆盖、读取中间态等问题。

3. 适用场景

• 多线程共享 Double 类型数据（如金额、分数、统计值等）的场景

• 需要高效原子更新操作，无需重量级锁的场景

• 对 Double 引用对象进行原子性替换、比较更新的场景

二、常用方法汇总

三、实战示例

1. 基础使用（单线程场景）

演示初始化、获取、设置、更新等基础操作：

import java.util.concurrent.atomic.AtomicReference;
public class AtomicReferenceDoubleBasicDemo {
    public static void main(String[] args) {
        // 1. 初始化：指定初始值（无参构造默认 null，需避免空指针）
        AtomicReference<Double> atomicDouble = new AtomicReference<>(100.0);
        // 2. 获取当前值
        Double current = atomicDouble.get();
        System.out.println("初始值：" + current); // 输出：初始值：100.0
        // 3. 直接设置新值
        atomicDouble.set(200.5);
        System.out.println("set 后的值：" + atomicDouble.get()); // 输出：set 后的值：200.5
        // 4. getAndSet：设置新值并返回旧值
        Double oldVal = atomicDouble.getAndSet(300.8);
        System.out.println("旧值：" + oldVal + "，新值：" + atomicDouble.get()); // 输出：旧值：200.5，新值：300.8
        // 5. updateAndGet：基于当前值计算（如累加 10）
        Double newVal = atomicDouble.updateAndGet(v -> v + 10);
        System.out.println("累加 10 后的值：" + newVal); // 输出：累加 10 后的值：310.8
    }
}

2. 多线程场景（核心：CAS 原子更新）

模拟 10 个线程同时累加 Double 值，验证线程安全：

import java.util.concurrent.atomic.AtomicReference;
public class AtomicReferenceDoubleThreadDemo {
    // 共享原子 Double 变量，初始值 0.0
    private static final AtomicReference&lt;Double&gt; TOTAL_SCORE = new AtomicReference<>(0.0);
    // 累加方法：使用 CAS 保证原子性
    public static void addScore(Double delta) {
        while (true) { // CAS 失败则重试
            // 1. 获取当前最新值
            Double current = TOTAL_SCORE.get();
            // 2. 计算目标值
            Double next = current + delta;
            // 3. CAS 比对更新：当前值未变则更新，成功则退出
            if (TOTAL_SCORE.compareAndSet(current, next)) {
                break;
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        // 创建 10 个线程，每个线程累加 10.5 分
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(() -> addScore(10.5));
            threads[i].start();
        }
        // 等待所有线程执行完毕
        for (Thread thread : threads) {
            thread.join();
        }
        // 预期结果：10 * 10.5 = 105.0
        System.out.println("最终总分：" + TOTAL_SCORE.get()); // 输出：最终总分：105.0
    }
}

四、关键注意事项

1. 包装类与空指针问题

AtomicReference<Double> 操作的是 Double 包装类，而非基本类型 double。若使用无参构造初始化（默认值为 null），调用 get() 时可能抛出 NullPointerException，建议初始化时指定默认值（如 0.0）。

2. CAS 的 ABA 问题

CAS 操作存在 ABA 问题：当值从 A 变为 B 后又变回 A，CAS 会认为值未修改而成功更新。若业务场景需避免此问题，可使用 AtomicStampedReference<Double>（带版本号的原子引用），通过版本号判断值是否被篡改。

3. 与 AtomicDouble 的区别

4. 性能优势与局限

优势：基于 CAS 无锁机制，多线程竞争不激烈时，性能优于 synchronized 锁。
局限：若多线程竞争激烈，CAS 重试次数会增多，性能可能下降，此时可考虑使用 LongAdder（针对数值类型）或分段锁。

五、核心总结

1. AtomicReference<Double> 核心价值：多线程下安全操作 Double 引用，通过 CAS 实现无锁原子更新。

2. 核心方法优先级：简单读写用 get()/set()，条件更新用 compareAndSet()，复杂计算用 updateAndGet()。

3. 避坑要点：初始化指定默认值防 NPE，高竞争场景注意 CAS 重试问题，敏感场景用 AtomicStampedReference 解决 ABA 问题。

   （注：文档部分内容可能由 AI 生成）