CAS操作怎么避免ABA问题？

**避免 ABA 的根法就是把“值是否相同”的比较，升级为“值 + 版本”一起比较**。在 Java 里常见有三招： # 1) 带版本号的 CAS（最通用） * **`AtomicStampedReference<T>`**：把引用和一个 `int` 版本号一起 CAS。 * **思路**：每次成功更新把版本 `stamp+1`，即使值从 A→B→A，**stamp 变了**，CAS 就会失败，从而发现 ABA。 最小示例（Treiber 栈，防 ABA）： ```java import java.util.concurrent.atomic.AtomicStampedReference; class Node { final int v; Node next; Node(int v){ this.v=v; } } class LockFreeStack { private final AtomicStampedReference<Node> head = new AtomicStampedReference<>(null, 0); public void push(int x) { Node n = new Node(x); while (true) { int[] s = new int[1]; Node h = head.get(s); n.next = h; if (head.compareAndSet(h, n, s[0], s[0] + 1)) return; // 成功并递增版本 } } public Integer pop() { while (true) { int[] s = new int[1]; Node h = head.get(s); if (h == null) return null; Node next = h.next; if (head.compareAndSet(h, next, s[0], s[0] + 1)) return h.v; } } } ``` * **`AtomicMarkableReference<T>`**：引用 + 一个 `boolean mark`。常用于**逻辑删除**（如无锁链表），只能标记“是否被删除”，**并不能完全消除 ABA**（因为只 1 bit）。 # 2) 把“值 + 版本”打包成一个整型一起 CAS（高性能） * 用 **`AtomicLong`/`VarHandle`** 把高位当版本、低位当值（或索引）。一次 CAS 比较整 64 位。 * 典型：环形队列/位图/索引表，把 **sequence（序号）** 与 **位置/状态**打包，按位操作。 示例（伪代码）： ```java // 低32位存"槽位索引"，高32位存"版本" AtomicLong state = new AtomicLong( pack(index, version) ); boolean cas(int expectIdx, int expectVer, int newIdx, int newVer) { long expect = ((long)expectVer << 32) | (expectIdx & 0xffffffffL); long update = ((long)newVer << 32) | (newIdx & 0xffffffffL); return state.compareAndSet(expect, update); } ``` # 3) 避免“同对象再利用”/延迟回收（结构层面的缓解） * 产生 ABA 的另一根源是**旧节点被移除后又很快复用**（指针/引用回到同一“值”）。 * 在 Java 里有 GC，不会像 C/C++ 那样立即复用同一地址，但**逻辑 ABA 依然可能**（同一引用被重新挂回结构）。 * 解决思路： * **不复用旧节点对象**（每次新建）；或确保复用前一定不会被旧的读取路径观测到（配合版本号更稳）。 * 更复杂的内存回收策略（Hazard Pointers、Epoch/RCU 等）主要用于无 GC 语言；Java 少见，但\*\*JUC 的无锁结构内部也普遍使用“标记 + 帮助清理（helping）”\*\*来避免 ABA 影响正确性。 # 什么时候用哪种？ * **对引用做 CAS（如无锁栈/链表头）** → 直接用 **`AtomicStampedReference`**（最省心），或把“引用 ID + 版本”打包进 `AtomicLong`。 * **只需知道节点是否被删除** → `AtomicMarkableReference`（轻量，但不完全防 ABA）。 * **环形缓冲/位图** → 打包到 `long`（高位版本号），吞吐和内存局部性更好。 * **能避免就避免**：能用 `ConcurrentLinkedQueue/LinkedTransferQueue` 等成熟 JUC 容器就别自己造轮子，它们已处理好 ABA/回收细节。 # 误区速记 * `volatile`/`AtomicInteger` **不能**解决 ABA（只能保证可见性/单值原子性）。 * `LongAdder` 与 ABA 无关。 * `synchronized` 天生不会有 ABA（根本不走乐观 CAS），但失去无锁的并发优势。 一句话：**在比较里引入“版本”维度**（引用+版本一起 CAS）是避免 ABA 的标准做法；Java 里用 `AtomicStampedReference` 最直接，或把版本和值打包成一个 `long` 做一次性 CAS。