Atomic 原子类

Atomic 原子类

📚 Java Atomic 原子类全解析

🌟 Atomic 类核心价值

Java 并发包中的原子类（java.util.concurrent.atomic）通过 硬件级原子指令（CAS） 实现了线程安全的无锁操作，解决了传统锁机制在高并发竞争场景下的性能瓶颈问题。其设计哲学是：用空间换时间，用算法换锁。

🧩 Atomic 家族成员全景图

Atomic 原子类体系
├── 基本类型
│   ├── AtomicInteger
│   ├── AtomicLong
│   └── AtomicBoolean
│
├── 引用类型
│   ├── AtomicReference
│   ├── AtomicStampedReference（带版本号）
│   └── AtomicMarkableReference（带标记位）
│
├── 数组类型
│   ├── AtomicIntegerArray
│   ├── AtomicLongArray
│   └── AtomicReferenceArray
│
├── 字段更新器
│   ├── AtomicIntegerFieldUpdater
│   ├── AtomicLongFieldUpdater
│   └── AtomicReferenceFieldUpdater
│
└── 高性能计数器
    ├── LongAdder（Java8+）
    └── DoubleAdder（Java8+）

⚙️ 核心原理：CAS（Compare And Swap）

CAS 操作流程

           +-----------------+
           | 读取内存值 V     |
           +-----------------+
                     |
                     v
+----------------------------------+
| 比较 V 与预期值 A                 |
| if (V == A) → 写入新值 B          | → 成功返回 true
| else        → 放弃操作            | → 失败返回 false
+----------------------------------+

CPU 硬件支持

• x86：LOCK CMPXCHG 指令
• ARM：LDREX/STREX 指令
• 原子性保障：缓存锁或总线锁

🔧 核心类详解与代码示例

1. AtomicInteger

AtomicInteger counter = new AtomicInteger(0);

// 原子递增
counter.incrementAndGet();  // 1

// 自定义更新
int result = counter.updateAndGet(x -> x * 2);  // 2

// 复合操作
boolean success = counter.compareAndSet(2, 5); // true

2. AtomicReference

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

// 原子替换
userRef.set(oldUser);
userRef.compareAndSet(oldUser, newUser); // 成功

3. LongAdder（分段锁优化）

LongAdder totalBytes = new LongAdder();

// 并发添加
parallelStream().forEach(i -> totalBytes.add(i));

// 获取最终结果（非实时）
long sum = totalBytes.sum();

4. AtomicStampedReference（解决 ABA 问题）

AtomicStampedReference<Integer> money = new AtomicStampedReference<>(100, 0);

int[] stampHolder = new int[1];
int current = money.get(stampHolder); // 值=100, 版本=0

// 带版本号的CAS操作
money.compareAndSet(100, 200, stampHolder[0], stampHolder[0]+1);

⚡ 性能对比：synchronized vs Atomic vs LongAdder

结论：

• 低竞争：Atomic 类比锁快 3-5 倍
• 高竞争：LongAdder 性能优势可达 20 倍

🛠️ Atomic 类最佳实践

1. 适用场景

✅ 计数器（访问量统计）
✅ 状态标志位（初始化标志）
✅ 对象属性原子更新
✅ 无锁数据结构（队列、栈）
✅ 实时性要求不高的统计

2. 避坑指南

// 错误示例：复合操作仍需保护
AtomicInteger count = new AtomicInteger(0);
if (count.get() < 10) {  // 此处存在竞态条件！
    count.incrementAndGet();
}

// 正确做法：使用CAS循环
while (true) {
    int current = count.get();
    if (current >= 10) break;
    if (count.compareAndSet(current, current+1)) break;
}

3. 内存可见性保障

所有原子类内部均使用 volatile 变量，保证：

• 可见性：修改立即对其他线程可见
• 有序性：防止指令重排序

🔄 Atomic 类设计模式

1. 无锁栈实现

public class LockFreeStack<T> {
    private AtomicReference<Node<T>> top = new AtomicReference<>();

    public void push(T item) {
        Node<T> newHead = new Node<>(item);
        Node<T> oldHead;
        do {
            oldHead = top.get();
            newHead.next = oldHead;
        } while (!top.compareAndSet(oldHead, newHead));
    }

    public T pop() {
        Node<T> oldHead;
        Node<T> newHead;
        do {
            oldHead = top.get();
            if (oldHead == null) return null;
            newHead = oldHead.next;
        } while (!top.compareAndSet(oldHead, newHead));
        return oldHead.item;
    }

    private static class Node<T> {
        final T item;
        Node<T> next;
        // 构造方法...
    }
}

2. 高效计数器组

class MetricCounter {
    private final AtomicLongArray counters;

    public MetricCounter(int size) {
        counters = new AtomicLongArray(size);
    }

    public void increment(int index) {
        counters.getAndIncrement(index);
    }

    public long getTotal() {
        long sum = 0;
        for (int i = 0; i < counters.length(); i++) {
            sum += counters.get(i);
        }
        return sum;
    }
}

⚖️ Atomic 类局限性

🌟 Java 8+ 增强特性

1. 增强型 API

AtomicInteger atomic = new AtomicInteger(5);

// 函数式更新
atomic.accumulateAndGet(3, Math::max); // 结果为5

// 延迟初始化
AtomicReference<ExpensiveObject> ref = new AtomicReference<>();
ExpensiveObject obj = ref.updateAndGet(
    o -> o != null ? o : createExpensiveObject()
);

2. Adder 系列优化

LongAdder → 适合统计场景（写多读少）
LongAccumulator → 支持自定义累加规则

💡 架构师思考

1. 成本权衡：

   • 开发成本：Atomic 类比锁更复杂
   • 维护成本：需要深入理解内存模型

2. 技术选型：

   单变量原子操作 → Atomic 系列
   分布式计数器 → Redis/ZooKeeper
   超高并发统计 → LongAdder + 定期持久化
   

3. 未来趋势：

   • 向量化 API（Valhalla 项目）
   • 硬件加速的原子指令

终极总结：
Atomic 类是 Java 并发编程的基石工具，它们：
🔹 用 CAS 取代锁实现无锁并发
🔹 通过 volatile 保证可见性
🔹 借 分段策略 优化高并发场景
掌握其原理与适用场景，是构建高性能 Java 应用的必备技能。

对于原子类相关 API 例子

以下是针对 Java Atomic 原子类家族各成员的详细 API 示例及区别分析：

一、基本类型原子类

1. AtomicInteger

AtomicInteger atomicInt = new AtomicInteger(0);

// 基础操作
atomicInt.set(10);                          // 设置值
int val = atomicInt.get();                  // 获取值 → 10

// 原子运算
int newVal = atomicInt.incrementAndGet();    // 递增 → 11
int oldVal = atomicInt.getAndAdd(5);         // 返回旧值 → 11，新值 → 16

// CAS 操作
boolean success = atomicInt.compareAndSet(16, 20); // true

// 函数式更新
atomicInt.updateAndGet(x -> x * 2);          // 20 → 40

2. AtomicLong

AtomicLong atomicLong = new AtomicLong(100L);

// 类似 AtomicInteger，支持大范围计数
atomicLong.addAndGet(50);                    // 150L
long current = atomicLong.getAndDecrement(); // 150 → 149

3. AtomicBoolean

AtomicBoolean atomicBool = new AtomicBoolean(false);

// 原子切换状态
boolean old = atomicBool.getAndSet(true);    // false → true

// 条件更新
boolean updated = atomicBool.compareAndSet(true, false); // true

二、引用类型原子类

1. AtomicReference

AtomicReference<String> ref = new AtomicReference<>("A");

// 更新引用
ref.set("B");
String oldVal = ref.getAndSet("C");          // "B" → "C"

// CAS 存在 ABA 问题
ref.compareAndSet("C", "D");                 // true

2. AtomicStampedReference（带版本号）

AtomicStampedReference<String> stampedRef = 
    new AtomicStampedReference<>("A", 0);

// 解决 ABA 问题
int[] stampHolder = new int[1];
String currentRef = stampedRef.get(stampHolder); // currentRef="A", stamp=0

// 更新时检查版本号
boolean success = stampedRef.compareAndSet(
    "A", "B", stampHolder[0], stampHolder[0] + 1); // 成功，版本号变为1

3. AtomicMarkableReference（带标记位）

AtomicMarkableReference<String> markableRef = 
    new AtomicMarkableReference<>("A", false);

// 使用布尔标记
boolean[] markHolder = new boolean[1];
String ref = markableRef.get(markHolder);    // ref="A", mark=false

// 更新标记位
markableRef.attemptMark("A", true);          // 标记为 true

三、数组类型原子类

1. AtomicIntegerArray

int[] arr = {1, 2, 3};
AtomicIntegerArray atomicArray = new AtomicIntegerArray(arr);

// 原子更新元素
atomicArray.set(0, 10);                      // 索引0 → 10
int val = atomicArray.getAndAdd(1, 5);       // 索引1: 2 → 7，返回旧值2

// CAS 操作
boolean updated = atomicArray.compareAndSet(2, 3, 30); // 索引2: 3 → 30

2. AtomicReferenceArray

AtomicReferenceArray<String> refArray = 
    new AtomicReferenceArray<>(new String[5]);

refArray.set(0, "Java");
String old = refArray.getAndUpdate(0, s -> s + "8"); // "Java" → "Java8"

四、字段更新器

1. AtomicIntegerFieldUpdater

class Counter {
    volatile int count; // 必须是 volatile
}

Counter obj = new Counter();
AtomicIntegerFieldUpdater<Counter> updater = 
    AtomicIntegerFieldUpdater.newUpdater(Counter.class, "count");

updater.addAndGet(obj, 5); // obj.count = 5

2. AtomicReferenceFieldUpdater

class Node {
    volatile Node next; // 必须是 volatile
}

Node head = new Node();
AtomicReferenceFieldUpdater<Node, Node> updater = 
    AtomicReferenceFieldUpdater.newUpdater(Node.class, Node.class, "next");

updater.compareAndSet(head, null, new Node()); // 更新 head.next

五、高性能计数器

1. LongAdder

LongAdder adder = new LongAdder();

// 并发累加（适合写多读少）
adder.add(10);
adder.increment();

// 获取总和（非精确实时值）
long sum = adder.sum();                      // 11

// 重置（不影响正在进行的累加）
adder.reset();                               // sum → 0

2. LongAccumulator（更通用）

LongAccumulator accumulator = 
    new LongAccumulator((x, y) -> x * y, 1); // 初始值1，累乘器

accumulator.accumulate(3);                   // 1*3=3
accumulator.accumulate(5);                   // 3*5=15
long result = accumulator.get();             // 15

六、核心区别总结

七、选型决策指南

1. 单变量计数

   • 低竞争 → AtomicInteger
   • 高竞争 → LongAdder

2. 对象引用更新

   • 无 ABA 问题 → AtomicReference
   • 需防 ABA → AtomicStampedReference

3. 数组元素原子操作

   • 基本类型 → AtomicIntegerArray
   • 对象 → AtomicReferenceArray

4. 修改现有类字段

   • 无侵入式修改 → AtomicXxxFieldUpdater

通过以上代码示例和对比，开发者可以清晰区分不同 Atomic 类的适用场景及核心 API 的使用方式。

AtomicInteger 与 LongAdder

📚 AtomicInteger 与 LongAdder 深度解析
本文将深入分析 Java 原子变量家族的两个核心类，通过代码示例详解 API 使用，并对比不同场景下的性能表现。

🧩 核心类对比

🔧 AtomicInteger API 详解

1. 基础操作

AtomicInteger ai = new AtomicInteger(0);

// 设置值（非原子）
ai.set(10); 

// 获取当前值
int current = ai.get(); // 10

// 原子设置并返回旧值
int old = ai.getAndSet(20); // old=10, ai=20

// 比较并交换（CAS）
boolean success = ai.compareAndSet(20, 30); // true

2. 原子运算

// 递增并获取新值
int newVal = ai.incrementAndGet(); // 31

// 获取并递增
int before = ai.getAndIncrement(); // 31 → ai=32

// 原子加法
int result = ai.addAndGet(5); // 32+5=37

// 自定义运算
int custom = ai.updateAndGet(x -> x * 2); // 37*2=74

3. 复杂操作

// 累积计算（线程安全版本）
int accumulated = ai.accumulateAndGet(10, (prev, x) -> prev + x); // 74+10=84

// 延迟初始化（常用于单例）
AtomicInteger lazy = new AtomicInteger();
int initialized = lazy.updateAndGet(x -> x == 0 ? 100 : x);

🚀 LongAdder API 详解

1. 基础操作

LongAdder adder = new LongAdder();

// 递增（无返回值）
adder.increment();       // +1
adder.add(5);            // +5

// 递减
adder.decrement();       // -1

// 重置计数器
adder.reset();           // 归零

// 获取当前值（非原子快照）
long sum = adder.sum();  // 5

2. 组合操作

// 先加后获取（类似 getAndAdd）
long beforeAdd = adder.sumThenReset(); // 返回当前值并重置

// 与其他Adder合并
LongAdder another = new LongAdder();
another.add(3);
adder.add(another.sum()); // adder=8

3. 统计场景

// 高并发统计示例
LongAdder totalRequests = new LongAdder();
LongAdder failedRequests = new LongAdder();

// 请求处理线程
void handleRequest() {
    totalRequests.increment();
    try {
        processRequest();
    } catch (Exception e) {
        failedRequests.increment();
    }
}

// 输出统计
System.out.printf("成功率: %.2f%%%n", 
    100 * (totalRequests.sum() - failedRequests.sum()) / (double)totalRequests.sum());

⚡ 性能对比测试

测试代码

@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public class CounterBenchmark {
    private AtomicInteger atomic = new AtomicInteger();
    private LongAdder adder = new LongAdder();

    // 线程数模拟不同并发级别
    @Param({"1", "4", "8"})
    private int threads;

    @Benchmark
    public void atomicIncrement(Blackhole bh) {
        atomic.incrementAndGet();
    }

    @Benchmark
    public void adderIncrement(Blackhole bh) {
        adder.increment();
    }
}

测试结果（ops/ms）

结论：

• 低并发：AtomicInteger 性能更优
• 高并发：LongAdder 吞吐量提升 6-8 倍

🛠️ 选型决策树

需要原子变量吗？
├─ 是 → 写操作是否高频？
│   ├─ 是 → LongAdder
│   └─ 否 → AtomicInteger
└─ 否 → 考虑其他同步机制

💡 最佳实践

AtomicInteger 适用场景

// 1. 简单计数器
AtomicInteger counter = new AtomicInteger();
requestHandlers.forEach(h -> 
    h.setOnSuccess(() -> counter.incrementAndGet())
);

// 2. 状态标志位
AtomicInteger status = new AtomicInteger(0);
if (status.compareAndSet(0, 1)) {
    // 执行初始化操作
}

LongAdder 适用场景

// 1. 实时数据统计
LongAdder bytesSent = new LongAdder();
networkService.addListener(bytes -> 
    bytesSent.add(bytes)
);

// 2. 高频计数器
LongAdder clickCounter = new LongAdder();
button.addClickListener(e -> 
    clickCounter.increment()
);

⚠️ 注意事项

4. LongAdder 的精度问题

   // sum() 只是近似值，如需精确值：
   long exactSum = adder.longValue(); // 等同于 sum()
   // 真正精确需要停止所有写操作
   

5. 内存消耗控制

   // 预估 Cell 数组大小（默认最大CPU核数）
   -Djava.util.concurrent.ForkJoinPool.common.parallelism=16
   

6. AtomicInteger 的 ABA 问题

   // 需要版本号控制时使用 AtomicStampedReference
   AtomicStampedReference<Integer> ref = 
       new AtomicStampedReference<>(0, 0);
   

🌟 高级技巧

自定义分段策略

// 继承 Striped64 实现自定义分散算法
class CustomAdder extends Striped64 {
    public void increment() {
        Cell[] cs; long b, v; int m;
        if ((cs = cells) != null || 
            !casBase(b = base, b + 1)) {
            // 自定义冲突处理逻辑
        }
    }
}

与并发容器配合

ConcurrentHashMap<String, LongAdder> counterMap = new ConcurrentHashMap<>();

// 统计单词频率
words.forEach(word -> 
    counterMap.computeIfAbsent(word, k -> new LongAdder()).increment()
);

总结：

• AtomicInteger：简单场景的瑞士军刀，保证强一致性
• LongAdder：高并发写场景的核武器，以空间换时间
  根据实际场景合理选择，可结合 JMH 进行性能测试验证。