原子类 Atomic

Atomic 类位于 java.util.concurrent.atomic 包，基于 CAS 实现无锁并发操作。

常用原子类

AtomicInteger 示例

基本操作

AtomicInteger count = new AtomicInteger(0);

// 获取当前值
int value = count.get();

// 设置值
count.set(10);

// 原子自增并返回新值
int newValue = count.incrementAndGet();

// 原子自减并返回新值
int newValue = count.decrementAndGet();

// 原子加指定值
int newValue = count.addAndGet(5);

// 原子更新（CAS）
count.compareAndSet(10, 20);  // 当前值为10则更新为20

替代 synchronized 计数

// synchronized 方式（有锁）
private int count = 0;
public synchronized void increment() {
    count++;
}

// Atomic 方式（无锁）
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
    count.incrementAndGet();  // 无锁，性能更高
}

AtomicReference 示例

AtomicReference<User> userRef = new AtomicReference<>(new User("Alice"));

// 原子更新引用
User oldUser = userRef.get();
User newUser = new User("Bob");
userRef.compareAndSet(oldUser, newUser);

// 或者使用 updateAndGet
userRef.updateAndGet(u -> new User(u.getName() + "-updated"));

LongAdder 高并发计数

LongAdder adder = new LongAdder();

// 增加
adder.increment();
adder.add(10);

// 获取总和（非精确，高并发下可能略有误差）
long sum = adder.sum();

// 重置
adder.reset();

LongAdder 优势：使用多个 Cell 分散热点，高并发写入性能远优于 AtomicLong。适合高并发计数场景，读取稍有开销。

CAS 原理

CAS（Compare And Swap）是 Atomic 类的核心：

// CAS 伪代码
public boolean compareAndSet(int expect, int update) {
    if (this.value == expect) {  // 比较当前值
        this.value = update;     // 相等则更新
        return true;
    }
    return false;  // 不相等返回失败
}

CAS 特点：

• 无锁，基于 CPU 原子指令
• 高并发下性能好
• 可能自旋等待（竞争激烈时开销增加）
• 只保证单变量原子性

Atomic vs synchronized

要点总结

• Atomic 类基于 CAS 实现无锁并发，性能优于 synchronized
• 常用：AtomicInteger、AtomicLong、AtomicReference
• 核心方法：get()、set()、incrementAndGet()、compareAndSet()
• CAS 保证单变量原子性，复合操作需其他机制
• LongAdder 适合高并发计数，性能优于 AtomicLong
• Atomic 适合单变量场景，多变量同步用 synchronized 或 Lock