Java并发利器：AtomicReference详解（小白也能掌握的原子引用使用指南）

什么是 AtomicReference？

AtomicReference 是 Java 中用于实现对对象引用的原子操作的工具类。所谓“原子操作”，指的是该操作在执行过程中不会被其他线程打断，从而保证了线程安全性。

与 synchronized 关键字或 ReentrantLock 不同，AtomicReference 使用的是底层 CPU 的 CAS（Compare-And-Swap）指令，因此性能更高，尤其适用于高并发场景。

为什么需要 AtomicReference？

假设你有一个共享的对象引用，在多个线程中需要更新它。如果不加控制，可能会出现以下问题：

• 线程 A 读取了引用值
• 线程 B 修改了引用值
• 线程 A 基于旧值进行修改并写回，导致线程 B 的修改丢失

这就是典型的“读-改-写”竞态条件（Race Condition）。而 AtomicReference 能通过原子操作避免此类问题。

AtomicReference 基本用法

首先，我们需要导入相关类：

import java.util.concurrent.atomic.AtomicReference;

创建一个 AtomicReference 实例：

AtomicReference<String> atomicRef = new AtomicReference<>("初始值");

常用方法包括：

• get()：获取当前值
• set(newValue)：设置新值（非原子复合操作）
• compareAndSet(expect, update)：如果当前值等于 expect，则原子地设为 update
• getAndSet(newValue)：原子地设置新值并返回旧值

实战示例：线程安全的状态切换

假设我们有一个任务状态机，状态只能从 "PENDING" → "RUNNING" → "COMPLETED"。我们希望多个线程尝试启动任务时，只有一个能成功。

import java.util.concurrent.atomic.AtomicReference;public class TaskRunner {    private AtomicReference<String> state = new AtomicReference<>("PENDING");    public boolean startTask() {        // 只有当前状态是 PENDING 时，才允许切换到 RUNNING        return state.compareAndSet("PENDING", "RUNNING");    }    public boolean completeTask() {        return state.compareAndSet("RUNNING", "COMPLETED");    }    public String getState() {        return state.get();    }    public static void main(String[] args) throws InterruptedException {        TaskRunner runner = new TaskRunner();        Thread t1 = new Thread(() -> {            if (runner.startTask()) {                System.out.println("线程1成功启动任务");                // 模拟任务执行                try { Thread.sleep(100); } catch (InterruptedException e) {}                runner.completeTask();            } else {                System.out.println("线程1启动失败");            }        });        Thread t2 = new Thread(() -> {            if (runner.startTask()) {                System.out.println("线程2成功启动任务");            } else {                System.out.println("线程2启动失败");            }        });        t1.start();        t2.start();        t1.join();        t2.join();        System.out.println("最终状态: " + runner.getState());    }}

运行结果可能如下：

线程1成功启动任务线程2启动失败最终状态: COMPLETED

这说明 AtomicReference 成功保证了只有一个线程能修改状态，体现了其在 Java并发编程 中的价值。

高级技巧：使用自定义对象

AtomicReference 不仅支持基本类型包装类，还可以用于任意对象。例如，我们可以用它来实现一个线程安全的计数器包装类：

class Counter {    private int value;    public Counter(int value) { this.value = value; }    public int getValue() { return value; }    public Counter increment() { return new Counter(this.value + 1); }    @Override    public String toString() { return "Counter{" + value + "}"; }}// 使用 AtomicReference 管理 Counter 对象AtomicReference<Counter> atomicCounter = new AtomicReference<>(new Counter(0));// 原子地增加计数boolean updated = false;while (!updated) {    Counter current = atomicCounter.get();    Counter next = current.increment();    updated = atomicCounter.compareAndSet(current, next);}System.out.println(atomicCounter.get()); // 输出 Counter{1}

这种“不可变对象 + CAS 循环”的模式是函数式并发编程的常见实践，能有效避免锁竞争，提升系统吞吐量。

总结

AtomicReference 是 Java 并发包中一个强大而轻量的工具，适用于需要对对象引用进行 线程安全 更新的场景。它基于 CAS 机制，避免了传统锁的开销，特别适合高并发、低冲突的环境。

通过本教程，你应该已经掌握了：

• AtomicReference 的基本概念和原理
• 如何使用 compareAndSet 实现状态机
• 如何结合不可变对象实现无锁并发

无论你是初学者还是有一定经验的开发者，掌握 原子引用 技术都将大大提升你在 Java并发编程 领域的能力。赶快在你的项目中试试吧！