一、原子操作类概述
Java并发包(java.util.concurrent.atomic)提供了一系列原子操作类，这些类通过无锁算法实现了线程安全的操作，相比传统的锁机制具有更高的性能。原子类基于CAS(Compare-And-Swap)指令实现，是现代并发编程的重要基础。
原子类主要分类：
- 基本类型：AtomicInteger、AtomicLong、AtomicBoolean
- 引用类型：AtomicReference、AtomicStampedReference、AtomicMarkableReference
- 数组类型：AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray
- 字段更新器：AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater
- 累加器：LongAdder、DoubleAdder（JDK8+）
- 累加器增强：LongAccumulator、DoubleAccumulator（JDK8+）
二、CAS原理深度解析
1. CAS操作语义
CAS是一种原子指令，包含三个操作数：
- 内存位置(V)
- 预期原值(A)
- 新值(B)
当且仅当V的值等于A时，处理器才会将V的值更新为B，否则不执行任何操作。无论哪种情况都会返回V的当前值。
2. Java中的CAS实现
Java通过Unsafe类提供CAS操作支持：
public final class Unsafe {public final native boolean compareAndSwapInt(Object o, long offset, int expected, int x);public final native boolean compareAndSwapLong(Object o, long offset, long expected, long x);public final native boolean compareAndSwapObject(Object o, long offset, Object expected, Object x);
}
3. CAS的三大问题
-
ABA问题：值从A变为B又变回A，CAS会认为没变化
- 解决方案：使用AtomicStampedReference添加版本号
-
循环时间长开销大：CAS失败会自旋重试，消耗CPU
- 解决方案：JVM支持pause指令降低CPU消耗
-
只能保证一个变量的原子操作
- 解决方案：使用AtomicReference保证多个变量的原子性
三、核心原子类实现分析
1. AtomicInteger源码解析
public class AtomicInteger extends Number {private static final Unsafe unsafe = Unsafe.getUnsafe();private static final long valueOffset;static {try {valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));} catch (Exception ex) { throw new Error(ex); }}private volatile int value;public final int getAndIncrement() {return unsafe.getAndAddInt(this, valueOffset, 1);}// Unsafe中的实现public final int getAndAddInt(Object o, long offset, int delta) {int v;do {v = getIntVolatile(o, offset);} while (!compareAndSwapInt(o, offset, v, v + delta));return v;}
}
2. LongAdder高性能原理
设计思想：分段CAS，减少竞争
- 内部维护一个Cell数组和base值
- 线程首先尝试更新base值
- 竞争激烈时，线程会分配到不同的Cell上进行更新
- 最终结果为base+∑Cell[i]
适用场景：高并发统计计数，不保证实时精确
四、原子类的典型应用
1. 计数器实现
public class Counter {private final AtomicLong count = new AtomicLong(0);public void increment() {count.incrementAndGet();}public long getCount() {return count.get();}
}
2. 单例模式优化
public class Singleton {private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<>();private Singleton() {}public static Singleton getInstance() {for (;;) {Singleton instance = INSTANCE.get();if (instance != null) {return instance;}instance = new Singleton();if (INSTANCE.compareAndSet(null, instance)) {return instance;}}}
}
3. 状态标志管理
public class StatusManager {private final AtomicBoolean status = new AtomicBoolean(false);public void enable() {status.set(true);}public boolean tryDisable() {return status.compareAndSet(true, false);}
}
五、原子类性能优化
1. 伪共享(False Sharing)问题
问题描述：多个线程修改同一缓存行的不同变量，导致性能下降
解决方案：
- JDK8使用@Contended注解自动填充（需开启JVM参数）
- 手动填充（对于非JDK8或特定场景）
public class PaddedAtomicLong extends AtomicLong {public volatile long p1, p2, p3, p4, p5, p6 = 7L; // 填充public PaddedAtomicLong(long initialValue) {super(initialValue);}
}
2. 计数器选型建议
| 场景 | 推荐类 | 原因 |
|---|---|---|
| 低竞争环境 | AtomicLong | 实现简单，开销小 |
| 高并发写入 | LongAdder | 分段减少竞争，吞吐量高 |
| 需要复杂累加操作 | LongAccumulator | 支持自定义累加函数 |
六、原子类与锁的性能对比
测试场景：100个线程，每个线程递增计数器100,000次
| 实现方式 | 耗时(ms) | 特点 |
|---|---|---|
| synchronized | 420 | 稳定但性能一般 |
| ReentrantLock | 380 | 略优于synchronized |
| AtomicInteger | 120 | 无锁，性能最好 |
| LongAdder | 85 | 高并发下性能最优 |
结论：在适合的场景下，原子类性能显著优于锁机制
七、原子类最佳实践
- 优先使用JDK提供的原子类：避免重复造轮子
- 理解内存语义：原子类保证可见性，但不保证操作的原子组合
- 注意ABA问题：必要时使用带版本号的原子引用
- 高并发计数使用LongAdder：比AtomicLong性能更好
- 避免过度使用：不是所有场景都需要原子类
八、常见问题与解决方案
1. 原子类能完全替代锁吗？
答案：不能。原子类适合简单原子操作，复杂同步仍需锁机制
2. 为什么AtomicInteger比synchronized快？
原因：
- 无上下文切换开销
- 硬件级CAS指令比JVM锁更轻量
- 非阻塞算法减少线程等待
3. 如何选择AtomicReference和AtomicStampedReference？
建议：
- 不关心ABA问题：使用AtomicReference
- 需要解决ABA问题：使用AtomicStampedReference
九、总结
Java原子操作类是基于CAS实现的高性能线程安全工具，理解其原理和适用场景对于编写高效并发程序至关重要。在实际开发中，应根据具体场景选择合适的原子类，并注意其内存语义和潜在问题。掌握原子类的使用技巧，能够在保证线程安全的同时获得接近于无锁的性能，是Java并发编程的高级技能之一。