概述
Java 的原子类(Atomic Classes)是 java.util.concurrent.atomic 包下的核心工具,它们通过 CAS(Compare-And-Swap) 机制实现了无锁的线程安全操作。相比传统的 synchronized 锁,原子类在高并发场景下(如计数器、状态标志)性能更高,因为它避免了线程阻塞和上下文切换的开销
基本类型原子类
- AtomicInteger
- AtomicLong
- AtomicBoolean
作用
提供对 int、long、boolean 类型变量的原子读写、自增自减、以及比较交换(CAS)操作。
使用示例
import java.util.concurrent.atomic.AtomicInteger;
public class Counter {
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet(); // 线程安全的 ++i
}
// 典型的 CAS 自旋操作
public void updateIfZero(int newValue) {
int oldValue;
do {
oldValue = count.get();
if (oldValue != 0) break;
} while (!count.compareAndSet(oldValue, newValue));
}
}
原理
- CAS 指令:利用 CPU 提供的原子指令(通过 Unsafe 类调用),包含三个操作数:内存位置(V)、预期原值(A)、新值(B)。仅当内存值等于预期值时,才将内存值更新为新值。
- volatile 语义:内部变量通常用 volatile 修饰,保证内存可见性(一个线程修改后,其他线程立即可见)。
注意事项
- ABA 问题:如果一个值从 A 变为 B,又变回 A,CAS 会认为它没有变化。虽然对于简单的计数器通常无害,但在某些业务场景下可能导致逻辑错误。解决方法见“引用类型原子类”。
- 自旋开销:如果竞争非常激烈,CAS 操作会不断重试(自旋),消耗 CPU 资源。
数组类型原子类
- AtomicIntegerArray
- AtomicLongArray
- AtomicReferenceArray
作用
保证数组中指定索引位置的元素更新是原子的。注意:是元素级别的原子性,不是整个数组的操作原子性。
使用示例
import java.util.concurrent.atomic.AtomicIntegerArray;
public class ArrayExample {
public static void main(String[] args) {
// 初始化长度为 10 的数组
AtomicIntegerArray array = new AtomicIntegerArray(10);
// 对索引 0 的元素进行原子自增
array.getAndIncrement(0); // 返回旧值,并将 array[0] 加 1
// 对索引 0 的元素进行 CAS 操作
boolean success = array.compareAndSet(0, 1, 100);
// 如果 array[0] 当前值是 1,则设为 100
}
}
原理
内部通常通过计算元素的内存偏移量,然后对那个特定的内存地址执行 CAS 操作
注意事项
数组本身一旦初始化,其引用不可变(类似 final 数组),你只能改变数组里的值,不能改变数组的长度。
引用类型原子类
- AtomicReference
- AtomicStampedReference
- AtomicMarkableReference
作用
- AtomicReference:对任意对象引用进行原子更新。
- AtomicStampedReference / AtomicMarkableReference:解决 ABA 问题
使用示例
AtomicReference
import java.math.BigDecimal;
import java.util.concurrent.atomic.AtomicReference;
public class NumberWrapperExample {
public static void main(String[] args) {
// 包装 Double
AtomicReference<Double> doubleRef = new AtomicReference<>(0.0);
// 新值 = func(旧值, x)
doubleRef.accumulateAndGet(1.5, (a, b) -> a + b);
System.out.println(doubleRef.get()); // 输出: 1.5
// 包装 BigDecimal (高精度计算)
AtomicReference<BigDecimal> bigDecimalRef =
new AtomicReference<>(BigDecimal.ZERO);
bigDecimalRef.accumulateAndGet(new BigDecimal("10.5"), BigDecimal::add);
System.out.println(bigDecimalRef.get()); // 输出: 10.5
}
}
AtomicStampedReference
import java.util.concurrent.atomic.AtomicStampedReference;
class User {
String name;
// 构造函数…
}
public class ReferenceExample {
// 使用版本号解决 ABA
private static final AtomicStampedReference<User> ref = new AtomicStampedReference<>(new User("Alice"), 0);
public static void safeUpdate() {
User oldUser = ref.getReference();
int stamp = ref.getStamp(); // 获取当前版本号
// 准备更新
User newUser = new User("Bob");
int newStamp = stamp + 1;
// 必须同时满足:引用未变 且 版本号未变,才能更新成功
boolean success = ref.compareAndSet(oldUser, newUser, stamp, newStamp);
}
}
原理
- AtomicReference:直接对对象的内存地址进行 CAS。
- AtomicStampedReference:通过“值 + 版本号(int stamp)”的配对来检查变化。只要版本号变了,即使值变回了原样,CAS 也会失败。
- AtomicMarkableReference:通过“值 + 标记位(boolean)”来标记是否被修改过。
注意事项
当你需要保证对象内部状态的一致性时,仅仅使用 AtomicReference 是不够的,还需要确保对象本身是不可变的(Immutable)或者其方法是线程安全的。


