原子类与CAS ⭐⭐⭐

/**
 * CAS 操作的伪代码实现（实际由 CPU 指令保证原子性）
 * 
 * @param memoryAddress 变量的内存地址
 * @param expectedValue 期望的当前值（我认为现在是什么）
 * @param newValue      想要更新成的新值
 * @return 操作是否成功
 */
boolean compareAndSwap(int memoryAddress, int expectedValue, int newValue) {
    // 第一步：读取内存地址中的当前值
    int currentValue = readFromMemory(memoryAddress);
    
    // 第二步：将当前值与期望值进行比较
    if (currentValue == expectedValue) {
        // 第三步：如果相等，说明没有其他线程修改过，将新值写入内存
        writeToMemory(memoryAddress, newValue);
        // 返回 true，表示 CAS 成功
        return true;
    }
    
    // 如果不相等，说明有其他线程已经修改了该值
    // 返回 false，表示 CAS 失败，本次不做任何修改
    return false;
}

import java.util.concurrent.atomic.AtomicInteger;
 
public class CasTripleOperandDemo {
 
    // 共享变量，初始值为 100，底层依赖 CAS 实现原子更新
    private static final AtomicInteger balance = new AtomicInteger(100);
 
    public static void main(String[] args) throws InterruptedException {
 
        // 线程 A：尝试将余额从 100 增加到 150
        Thread threadA = new Thread(() -> {
            // 读取当前值作为期望值 A
            int expected = balance.get();           // expected(A) = 100
            int newValue = expected + 50;           // newValue(B) = 150
 
            // 模拟线程 A 在 CAS 之前发生了短暂延迟
            try { Thread.sleep(50); } catch (InterruptedException e) { /* ignored */ }
 
            // 执行 CAS：compareAndSet(期望值A, 新值B)
            // 底层会读取内存值 V，比较 V == A ?
            boolean success = balance.compareAndSet(expected, newValue);
 
            // 打印 CAS 结果
            System.out.println("Thread-A: expected=" + expected
                    + ", newValue=" + newValue
                    + ", success=" + success
                    + ", currentBalance=" + balance.get());
        }, "Thread-A");
 
        // 线程 B：尝试将余额从 100 减少到 80
        Thread threadB = new Thread(() -> {
            // 读取当前值作为期望值 A
            int expected = balance.get();           // expected(A) = 100
            int newValue = expected - 20;           // newValue(B) = 80
 
            // 线程 B 没有延迟，会先于线程 A 完成 CAS
            boolean success = balance.compareAndSet(expected, newValue);
 
            // 打印 CAS 结果
            System.out.println("Thread-B: expected=" + expected
                    + ", newValue=" + newValue
                    + ", success=" + success
                    + ", currentBalance=" + balance.get());
        }, "Thread-B");
 
        // 启动两个线程
        threadA.start();
        threadB.start();
 
        // 等待两个线程执行完成
        threadA.join();
        threadB.join();
 
        // 输出最终余额
        System.out.println("Final balance: " + balance.get());
    }
}

import java.util.concurrent.atomic.AtomicInteger;
 
public class CasSpinDemo {
 
    // 共享的原子变量
    private static final AtomicInteger counter = new AtomicInteger(0);
 
    /**
     * 基于 CAS 自旋实现的无锁自增操作
     * 这就是 AtomicInteger.incrementAndGet() 的简化版原理
     */
    public static int safeIncrement() {
        // 无限循环（自旋），直到 CAS 成功
        for (;;) {
            // 第一步：读取当前值，作为期望值 A
            int current = counter.get();
 
            // 第二步：计算新值 B
            int next = current + 1;
 
            // 第三步：执行 CAS —— 若内存值仍为 current，则更新为 next
            if (counter.compareAndSet(current, next)) {
                // CAS 成功，跳出循环，返回更新后的值
                return next;
            }
            // CAS 失败，说明有其他线程在此期间修改了 counter
            // 不做任何处理，直接进入下一轮循环重试
            // 这就是"自旋"——线程不会被阻塞，而是持续尝试
        }
    }
 
    public static void main(String[] args) throws InterruptedException {
        // 创建 10 个线程，每个线程对 counter 自增 10000 次
        Thread[] threads = new Thread[10];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    safeIncrement();    // 调用无锁自增
                }
            });
            threads[i].start();         // 启动线程
        }
 
        // 等待所有线程执行完成
        for (Thread t : threads) {
            t.join();
        }
 
        // 最终结果一定是 100000（10 线程 × 10000 次）
        // 证明 CAS 自旋确实保证了线程安全
        System.out.println("Final counter: " + counter.get());
    }
}

// Unsafe.java 中的方法（JDK 源码简化版）
public final int getAndAddInt(Object obj, long offset, int delta) {
    int expected;                                   // 期望值（上次读取的值）
    do {
        // 以 volatile 语义读取对象 obj 在偏移量 offset 处的 int 值
        expected = this.getIntVolatile(obj, offset);
 
    // compareAndSwapInt：原子地比较并交换
    // 如果 obj 在 offset 处的当前值 == expected，则设为 expected + delta
    // 返回 true 表示成功，false 表示失败（有其他线程修改了）
    } while (!this.compareAndSwapInt(obj, offset, expected, expected + delta));
 
    // 循环退出时，CAS 已成功，返回旧值 expected
    return expected;
}

// Unsafe 类的核心结构（简化版）
public final class sun.misc.Unsafe {
 
    // 私有构造方法，禁止外部实例化
    private Unsafe() {}
 
    // 全局唯一实例，由 JVM 启动时初始化
    private static final Unsafe theUnsafe = new Unsafe();
 
    // 公开获取方法——但会做 ClassLoader 安全检查
    @CallerSensitive
    public static Unsafe getUnsafe() {
        Class<?> caller = Reflection.getCallerClass();
        // 如果调用者不是由 Bootstrap ClassLoader 加载的，直接拒绝
        if (!VM.isSystemDomainLoader(caller.getClassLoader()))
            throw new SecurityException("Unsafe");
        return theUnsafe;
    }
}

// 通过反射获取 Unsafe 实例（仅供学习理解，生产环境慎用）
Field f = Unsafe.class.getDeclaredField("theUnsafe"); // 获取私有静态字段
f.setAccessible(true);                                 // 绕过访问控制
Unsafe unsafe = (Unsafe) f.get(null);                  // 静态字段，传 null 即可

public class AtomicInteger extends Number implements java.io.Serializable {
 
    // 1. 获取 Unsafe 实例
    //    AtomicInteger 属于 java.util.concurrent.atomic 包，
    //    由 Bootstrap ClassLoader 加载，所以可以直接获取
    private static final Unsafe unsafe = Unsafe.getUnsafe();
 
    // 2. value 字段在 AtomicInteger 对象内存中的偏移量
    //    这个偏移量在类加载时就计算好了，后续所有 CAS 操作都依赖它
    private static final long valueOffset;
 
    // 3. 静态初始化块：在类加载阶段计算 valueOffset
    static {
        try {
            // objectFieldOffset: 返回 "value" 字段相对于对象起始地址的字节偏移量
            // 例如：对象头占 12 字节（64位JVM + 压缩指针），那么 valueOffset 可能是 12
            valueOffset = unsafe.objectFieldOffset(
                AtomicInteger.class.getDeclaredField("value")
            );
        } catch (Exception ex) {
            throw new Error(ex);
        }
    }
 
    // 4. 实际存储的值，声明为 volatile 保证可见性
    //    volatile 确保任何线程读取 value 时，都能看到最新的写入
    private volatile int value;
 
    // 5. 经典的 CAS 方法：compareAndSet
    //    期望当前值为 expect，如果是，则更新为 update
    public final boolean compareAndSet(int expect, int update) {
        // this     -> 当前 AtomicInteger 对象实例
        // valueOffset -> value 字段的内存偏移量
        // expect   -> 期望值 A
        // update   -> 新值 B
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
 
    // 6. getAndIncrement（i++ 的原子版本）——自旋 CAS 的经典模式
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
}

// Unsafe 类中的 getAndAddInt 方法（JDK 8+ 源码）
public final int getAndAddInt(Object o, long offset, int delta) {
    int v;                                  // 用于存储每次读到的最新值
    do {
        v = getIntVolatile(o, offset);      // 第一步：以 volatile 语义读取当前内存值
                                            //   这里保证读到的是最新的值（跨越内存屏障）
    } while (!compareAndSwapInt(o, offset, v, v + delta));
                                            // 第二步：尝试 CAS
                                            //   期望值 = v（刚刚读到的值）
                                            //   新值 = v + delta（v + 1）
                                            //   如果此刻内存值仍然是 v，CAS 成功，退出循环
                                            //   如果被其他线程改过了，CAS 失败，返回 false
                                            //   while 条件为 true，继续下一轮自旋
    return v;                               // 返回修改前的旧值（符合 getAndXxx 语义）
}

// Unsafe.java 中的声明
// 这是一个 native 方法，实现在 JVM 的 C/C++ 代码中
public final native boolean compareAndSwapInt(
    Object o,       // 目标对象
    long offset,    // 字段在对象中的内存偏移量
    int expected,   // 期望值（"我认为当前值应该是这个"）
    int x           // 新值（"如果猜对了，就改成这个"）
);

// hotspot/src/share/vm/prims/unsafe.cpp（简化版）
// UNSAFE_ENTRY 是 Hotspot 内部的宏，用于定义 native 方法的入口
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(
    JNIEnv *env,       // JNI 环境指针
    jobject unsafe,     // Unsafe 对象自身（Java 层的 this）
    jobject obj,        // 目标 Java 对象
    jlong offset,       // 字段偏移量
    jint e,             // expected 期望值
    jint x              // x 新值
)) {
    // 1. 将 Java 对象引用解析为 JVM 内部的 oop（Ordinary Object Pointer）
    oop p = JNIHandles::resolve(obj);
 
    // 2. 根据对象起始地址 + 偏移量，计算出 value 字段的真实内存地址
    jint* addr = (jint *)index_oop_plus_offset(p, offset);
 
    // 3. 调用 Atomic::cmpxchg 执行底层原子比较交换
    //    参数：新值 x，目标内存地址 addr，期望值 e
    //    返回值：内存地址中原来的值
    //    如果返回值 == e，说明 CAS 成功
    return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
} UNSAFE_END

// CMPXCHG dest, src 的等价伪代码
// dest: 目标操作数（通常是内存地址）
// src:  源操作数（通常是寄存器，存放新值）
// EAX:  隐式操作数（存放期望值）
 
if (EAX == dest) {          // 比较：EAX 中的期望值 vs 目标内存中的当前值
    ZF = 1;                 // 设置零标志位 ZF=1，表示"相等"
    dest = src;             // 交换：将新值写入目标内存
} else {
    ZF = 0;                 // 清除零标志位 ZF=0，表示"不相等"
    EAX = dest;             // 将目标内存的实际值回写到 EAX
                            // 这样调用者可以知道"当前值到底是什么"
}
// 整个 if-else 在 CPU 微架构层面是一个不可分割的操作

// hotspot/src/os_cpu/linux_x86/vm/atomic_linux_x86.inline.hpp（简化）
inline jint Atomic::cmpxchg(jint exchange_value,    // 新值（想要写入的值）
                             volatile jint* dest,    // 目标内存地址
                             jint compare_value) {   // 期望值
    int mp = os::is_MP();  // 判断是否为多处理器（Multi-Processor）系统
    
    __asm__ volatile (
        // LOCK_IF_MP: 如果是多处理器系统，则加 LOCK 前缀
        // 单处理器不需要 LOCK 前缀，因为单核 CMPXCHG 天然是原子的
        LOCK_IF_MP(%4)
        
        // cmpxchgl: CMPXCHG 的 32 位版本（l = long, 在 AT&T 汇编中表示 32 位）
        // %1 是 exchange_value（新值），放在某个通用寄存器中
        // (%3) 是 dest 指向的内存地址
        // 隐含操作数 EAX 中存放 compare_value（期望值）
        "cmpxchgl %1, (%3)"
        
        : "=a" (exchange_value)  // 输出：EAX 的值（操作后的旧值）赋给 exchange_value
        : "r"  (exchange_value), // 输入：新值放入任意通用寄存器
          "a"  (compare_value),  // 输入：期望值放入 EAX 寄存器（"a" 约束）
          "r"  (dest),           // 输入：目标地址放入任意通用寄存器
          "r"  (mp)              // 输入：多处理器标志
        : "cc", "memory"         // 破坏描述：会修改条件码寄存器和内存
    );
    return exchange_value;       // 返回 EAX 中的值（即操作前内存中的实际旧值）
}

// LOCK_IF_MP 宏的定义
#define LOCK_IF_MP(mp) "cmp $0, " #mp "; je 1f; lock; 1: "
 
// 展开后的等价逻辑：
// cmp $0, mp       ; 比较 mp（是否多处理器）和 0
// je 1f            ; 如果 mp==0（单处理器），跳过 lock 前缀
// lock             ; 如果 mp!=0（多处理器），添加 LOCK 前缀
// 1:               ; 标签，紧接着执行 cmpxchgl 指令

// CAS 的保障层次模型
 
// ┌─────────────────────────────────────────────────────────┐
// │  Java 语义层                                             │
// │  AtomicInteger.compareAndSet(expect, update)             │
// │  保证：原子性 + volatile 读写语义 (happens-before)        │
// ├─────────────────────────────────────────────────────────┤
// │  JVM 实现层                                              │
// │  Unsafe.compareAndSwapInt → Atomic::cmpxchg              │
// │  保证：正确映射到平台相关的原子指令                        │
// ├─────────────────────────────────────────────────────────┤
// │  CPU 指令层                                              │
// │  LOCK CMPXCHG（多处理器）/ CMPXCHG（单处理器）           │
// │  保证：指令级原子执行 + 内存屏障                          │
// ├─────────────────────────────────────────────────────────┤
// │  硬件协议层                                              │
// │  MESI 缓存一致性协议 + 总线嗅探 / 缓存锁 / 总线锁       │
// │  保证：多核间数据一致性                                   │
// └─────────────────────────────────────────────────────────┘

import java.util.concurrent.atomic.AtomicInteger;
 
public class ABADemo {
 
    // 共享的原子变量，初始值为 100
    private static AtomicInteger atomicInt = new AtomicInteger(100);
 
    public static void main(String[] args) throws InterruptedException {
 
        // ========== 线程 T1：制造 ABA ==========
        Thread t1 = new Thread(() -> {
            // 第一步：将 100 改为 101（A → B）
            boolean firstSwap = atomicInt.compareAndSet(100, 101);
            // 输出：true，值变为 101
            System.out.println("T1 第一次 CAS(100→101): " + firstSwap);
 
            // 第二步：将 101 改回 100（B → A）
            boolean secondSwap = atomicInt.compareAndSet(101, 100);
            // 输出：true，值又变回 100
            System.out.println("T1 第二次 CAS(101→100): " + secondSwap);
        }, "T1");
 
        // ========== 线程 T2：被 ABA 欺骗 ==========
        Thread t2 = new Thread(() -> {
            try {
                // 先读取到值 100（期望值 A）
                // 然后故意睡眠 1 秒，给 T1 足够时间完成 A→B→A
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            // T2 醒来后执行 CAS：期望值 100，新值 200
            // 此时值确实是 100（但已经历了 100→101→100）
            boolean result = atomicInt.compareAndSet(100, 200);
            // 输出：true —— T2 完全不知道值曾被修改过！
            System.out.println("T2 CAS(100→200): " + result
                    + "  当前值: " + atomicInt.get());
        }, "T2");
 
        t1.start(); // 启动 T1
        t2.start(); // 启动 T2
 
        t1.join();   // 等待 T1 完成
        t2.join();   // 等待 T2 完成
    }
}

import java.util.concurrent.atomic.AtomicReference;
 
public class ABALinkedListHazard {
 
    // 栈节点定义
    static class Node {
        int value;        // 节点存储的值
        Node next;        // 指向下一个节点的引用
 
        Node(int value) {
            this.value = value;
        }
 
        @Override
        public String toString() {
            return "Node(" + value + ")";
        }
    }
 
    // 栈顶指针，使用 AtomicReference 实现无锁
    private AtomicReference<Node> top = new AtomicReference<>();
 
    // 入栈操作
    public void push(Node node) {
        Node oldTop;
        do {
            oldTop = top.get();           // 读取当前栈顶
            node.next = oldTop;           // 新节点的 next 指向当前栈顶
        } while (!top.compareAndSet(oldTop, node)); // CAS 尝试更新栈顶
    }
 
    // 出栈操作 —— 存在 ABA 风险！
    public Node pop() {
        Node oldTop;
        Node newTop;
        do {
            oldTop = top.get();           // 读取当前栈顶
            if (oldTop == null) {         // 栈为空
                return null;
            }
            newTop = oldTop.next;         // 读取栈顶的下一个节点
            // 关键：如果在此处线程被挂起，其他线程修改了栈结构
            // 再恢复时，oldTop 可能已经不是"原来那个上下文"中的节点了
        } while (!top.compareAndSet(oldTop, newTop)); // CAS 尝试更新栈顶
        return oldTop;
    }
 
    public static void main(String[] args) throws InterruptedException {
        ABALinkedListHazard stack = new ABALinkedListHazard();
 
        // 构建初始栈：A → B → C
        Node nodeC = new Node(3);  // C
        Node nodeB = new Node(2);  // B
        Node nodeA = new Node(1);  // A
        stack.push(nodeC);         // 先压入 C
        stack.push(nodeB);         // 再压入 B
        stack.push(nodeA);         // 最后压入 A，此时 top → A → B → C
 
        System.out.println("初始栈顶: " + stack.top.get());
        // 输出: Node(1)，即 A
 
        // 模拟 T1：读取 top=A, A.next=B 后被挂起
        // 模拟 T2：pop A, pop B, push A（A.next 现在指向 C）
        stack.pop();               // pop A，栈: B → C
        stack.pop();               // pop B，栈: C
        nodeA.next = nodeC;        // 重新设置 A.next 指向 C
        stack.push(nodeA);         // push A，栈: A → C
 
        System.out.println("T2 操作后栈顶: " + stack.top.get());
        // 输出: Node(1)，即 A —— 看起来和初始状态一样！
 
        // 如果此时 T1 恢复，它持有的旧 newTop 仍然是 B
        // CAS(top, A, B) 会成功，但 B 早已不在栈中
        // 这就是 ABA 的危害
    }
}

import java.util.concurrent.atomic.AtomicStampedReference;
 
public class ABAResolutionDemo {
 
    public static void main(String[] args) throws InterruptedException {
 
        // 初始值为 100，初始版本号（stamp）为 1
        AtomicStampedReference<Integer> stampedRef =
                new AtomicStampedReference<>(100, 1);
 
        // ========== 线程 T1：制造 ABA ==========
        Thread t1 = new Thread(() -> {
            // 获取当前版本号
            int stamp = stampedRef.getStamp();
            System.out.println("T1 初始 stamp: " + stamp);
 
            // A → B：将 100 改为 101，版本号从 1 改为 2
            stampedRef.compareAndSet(
                    100,        // 期望的引用值
                    101,        // 新的引用值
                    stamp,      // 期望的版本号
                    stamp + 1   // 新的版本号
            );
            System.out.println("T1 第一次修改后: value="
                    + stampedRef.getReference()
                    + ", stamp=" + stampedRef.getStamp());
 
            // B → A：将 101 改回 100，版本号从 2 改为 3
            stamp = stampedRef.getStamp(); // 重新获取版本号
            stampedRef.compareAndSet(
                    101,        // 期望的引用值
                    100,        // 新的引用值（改回原值！）
                    stamp,      // 期望的版本号
                    stamp + 1   // 新的版本号
            );
            System.out.println("T1 第二次修改后: value="
                    + stampedRef.getReference()
                    + ", stamp=" + stampedRef.getStamp());
        }, "T1");
 
        // ========== 线程 T2：尝试被 ABA 欺骗 ==========
        Thread t2 = new Thread(() -> {
            // T2 在最开始就记录下 value 和 stamp
            int stamp = stampedRef.getStamp();          // 记录版本号 = 1
            Integer value = stampedRef.getReference();   // 记录值 = 100
            System.out.println("T2 读取到: value=" + value + ", stamp=" + stamp);
 
            try {
                // 睡眠 2 秒，确保 T1 完成 ABA 操作
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
 
            // T2 醒来后尝试 CAS
            // 值确实是 100，但版本号已经从 1 变成了 3
            boolean result = stampedRef.compareAndSet(
                    value,      // 期望的引用值: 100 ✅（值匹配）
                    200,        // 新的引用值
                    stamp,      // 期望的版本号: 1 ❌（实际已经是 3！）
                    stamp + 1   // 新的版本号
            );
            // CAS 失败！因为版本号不匹配
            System.out.println("T2 CAS 结果: " + result
                    + "  当前 value=" + stampedRef.getReference()
                    + ", stamp=" + stampedRef.getStamp());
        }, "T2");
 
        t1.start(); // 启动 T1
        t2.start(); // 启动 T2
 
        t1.join();   // 等待 T1 完成
        t2.join();   // 等待 T2 完成
    }
}

// AtomicInteger.getAndIncrement() 最终调用的是 Unsafe.getAndAddInt()
// 以下为 JDK 8+ 中 Unsafe.getAndAddInt 的实现逻辑
public final int getAndAddInt(Object obj, long offset, int delta) {
    int expected;                               // 期望值
    do {
        // 每次循环都从主内存重新读取最新值
        expected = this.getIntVolatile(obj, offset);
        // 尝试 CAS：如果当前值等于 expected，则更新为 expected + delta
        // 如果失败（说明其他线程已修改），继续循环
    } while (!this.compareAndSwapInt(obj, offset, expected, expected + delta));
    return expected;                            // 返回修改前的旧值
}

import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;
 
public class SpinOverheadBenchmark {
 
    // 共享的原子计数器
    private static final AtomicLong atomicLong = new AtomicLong(0);
    // JDK 8 引入的分段累加器
    private static final LongAdder longAdder = new LongAdder();
 
    // 每个线程的累加次数
    private static final int ITERATIONS = 10_000_000;
    // 并发线程数
    private static final int THREAD_COUNT = 64;
 
    public static void main(String[] args) throws InterruptedException {
 
        // ===== 测试 AtomicLong =====
        long start1 = System.currentTimeMillis();         // 记录开始时间
        Thread[] threads1 = new Thread[THREAD_COUNT];     // 线程数组
        for (int i = 0; i < THREAD_COUNT; i++) {
            threads1[i] = new Thread(() -> {
                for (int j = 0; j < ITERATIONS; j++) {
                    atomicLong.incrementAndGet();          // 自旋 CAS 累加
                }
            });
            threads1[i].start();                          // 启动线程
        }
        for (Thread t : threads1) t.join();               // 等待所有线程完成
        long elapsed1 = System.currentTimeMillis() - start1;
        System.out.println("AtomicLong   耗时: " + elapsed1 + "ms, 结果: "
                + atomicLong.get());
 
        // ===== 测试 LongAdder =====
        long start2 = System.currentTimeMillis();         // 记录开始时间
        Thread[] threads2 = new Thread[THREAD_COUNT];     // 线程数组
        for (int i = 0; i < THREAD_COUNT; i++) {
            threads2[i] = new Thread(() -> {
                for (int j = 0; j < ITERATIONS; j++) {
                    longAdder.increment();                // 分段累加，减少竞争
                }
            });
            threads2[i].start();                          // 启动线程
        }
        for (Thread t : threads2) t.join();               // 等待所有线程完成
        long elapsed2 = System.currentTimeMillis() - start2;
        System.out.println("LongAdder    耗时: " + elapsed2 + "ms, 结果: "
                + longAdder.sum());
    }
}

import java.util.concurrent.atomic.AtomicInteger;
 
public class SingleVariableLimitation {
 
    // 两个独立的原子变量：账户 A 和账户 B
    private static AtomicInteger accountA = new AtomicInteger(1000);
    private static AtomicInteger accountB = new AtomicInteger(1000);
 
    /**
     * 转账方法 —— 此实现是【有缺陷的】！
     * 两个 CAS 操作不是原子的整体
     */
    public static void transfer(int amount) {
        // 第一步：从 A 扣款
        int oldA;
        do {
            oldA = accountA.get();                          // 读取 A 的余额
            if (oldA < amount) {                            // 余额不足
                System.out.println("A 余额不足，转账失败");
                return;
            }
        } while (!accountA.compareAndSet(oldA, oldA - amount)); // CAS 扣款
 
        // ⚠️ 危险窗口：如果线程在此处被中断或抛异常
        //     A 已经扣了钱，但 B 还没收到钱！
        //     资金凭空消失了！
 
        // 第二步：向 B 加款
        int oldB;
        do {
            oldB = accountB.get();                          // 读取 B 的余额
        } while (!accountB.compareAndSet(oldB, oldB + amount)); // CAS 加款
    }
 
    public static void main(String[] args) {
        System.out.println("转账前 → A: " + accountA.get() + ", B: " + accountB.get());
        transfer(100);
        System.out.println("转账后 → A: " + accountA.get() + ", B: " + accountB.get());
        // 看起来正确，但在并发下两步之间的间隙是不安全的
    }
}

import java.util.concurrent.atomic.AtomicReference;
 
public class MultiVarAtomicSolution {
 
    /**
     * 将两个账户的余额封装为一个不可变对象
     * 每次修改都创建新对象，通过 AtomicReference CAS 整体替换
     */
    static class BankState {
        final int balanceA; // 账户 A 余额（final 保证不可变）
        final int balanceB; // 账户 B 余额（final 保证不可变）
 
        BankState(int a, int b) {
            this.balanceA = a;
            this.balanceB = b;
        }
 
        @Override
        public String toString() {
            return "A=" + balanceA + ", B=" + balanceB;
        }
    }
 
    // 用 AtomicReference 包装整个状态
    private static AtomicReference<BankState> stateRef =
            new AtomicReference<>(new BankState(1000, 1000));
 
    /**
     * 无锁转账 —— 正确实现
     * 通过 CAS 整体替换 BankState 对象来保证原子性
     */
    public static boolean transfer(int amount) {
        BankState oldState;           // 旧状态
        BankState newState;           // 新状态
        do {
            oldState = stateRef.get();                      // 读取当前状态快照
            if (oldState.balanceA < amount) {               // 检查 A 余额是否充足
                return false;                               // 余额不足，转账失败
            }
            // 构造新的不可变状态对象（A 扣款，B 加款）
            newState = new BankState(
                    oldState.balanceA - amount,              // A 减少
                    oldState.balanceB + amount               // B 增加
            );
            // CAS 整体替换：如果期间没人修改过状态，则替换成功
        } while (!stateRef.compareAndSet(oldState, newState));
        return true;                                        // 转账成功
    }
 
    public static void main(String[] args) throws InterruptedException {
        System.out.println("转账前: " + stateRef.get());
 
        // 启动 10 个线程，每个转账 50 元
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(() -> {
                transfer(50);  // 每个线程从 A 向 B 转 50 元
            });
            threads[i].start();
        }
        for (Thread t : threads) t.join();
 
        System.out.println("转账后: " + stateRef.get());
        // A=500, B=1500 —— 总额始终为 2000，正确！
 
        // 验证资金总额守恒
        BankState finalState = stateRef.get();
        System.out.println("资金总额: " + (finalState.balanceA + finalState.balanceB));
        // 输出: 2000
    }
}

public class AtomicInteger extends Number implements java.io.Serializable {
    // Unsafe 实例，用于直接操作内存
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    // value 字段在 AtomicInteger 对象中的内存偏移量
    private static final long valueOffset;
 
    static {
        try {
            // 通过反射获取 value 字段的偏移量，CAS 操作需要它来定位内存地址
            valueOffset = unsafe.objectFieldOffset(
                AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
 
    // 实际存储的 int 值，volatile 保证多线程可见性
    private volatile int value;
 
    // 构造方法：指定初始值
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }
 
    // 无参构造：默认值为 0
    public AtomicInteger() {
    }
}

import java.util.concurrent.atomic.AtomicInteger;
 
public class AtomicIntegerDemo {
    public static void main(String[] args) {
        // 创建一个初始值为 10 的 AtomicInteger
        AtomicInteger atomicInt = new AtomicInteger(10);
 
        // ========== 基本读写 ==========
        // get()：获取当前值
        int current = atomicInt.get();               // current = 10
 
        // set()：直接设置新值（volatile 写，保证可见性但非原子复合操作）
        atomicInt.set(20);                           // value = 20
 
        // lazySet()：最终会设置成功，但不保证立即对其他线程可见（性能优化，使用 StoreStore 屏障而非 StoreLoad）
        atomicInt.lazySet(30);                       // value 最终 = 30
 
        // ========== 原子更新 ==========
        // getAndSet()：原子地设置新值并返回旧值（类似 "交换"）
        int old = atomicInt.getAndSet(50);           // old = 30, value = 50
 
        // compareAndSet(expect, update)：CAS 核心方法
        // 仅当当前值等于 expect 时，才将值更新为 update，返回是否成功
        boolean success = atomicInt.compareAndSet(50, 60);  // success = true, value = 60
        boolean fail = atomicInt.compareAndSet(50, 70);     // fail = false, value 仍为 60
 
        // ========== 原子递增/递减 ==========
        // getAndIncrement()：先获取当前值，再 +1（等价于 i++）
        int beforeInc = atomicInt.getAndIncrement(); // beforeInc = 60, value = 61
 
        // incrementAndGet()：先 +1，再获取新值（等价于 ++i）
        int afterInc = atomicInt.incrementAndGet();  // afterInc = 62, value = 62
 
        // getAndDecrement()：先获取当前值，再 -1（等价于 i--）
        int beforeDec = atomicInt.getAndDecrement(); // beforeDec = 62, value = 61
 
        // decrementAndGet()：先 -1，再获取新值（等价于 --i）
        int afterDec = atomicInt.decrementAndGet();  // afterDec = 60, value = 60
 
        // ========== 原子加法 ==========
        // getAndAdd(delta)：先获取旧值，再加上 delta
        int beforeAdd = atomicInt.getAndAdd(5);      // beforeAdd = 60, value = 65
 
        // addAndGet(delta)：先加上 delta，再获取新值
        int afterAdd = atomicInt.addAndGet(5);       // afterAdd = 70, value = 70
 
        // ========== 函数式更新（Java 8+）==========
        // getAndUpdate(UnaryOperator)：先获取旧值，再用 lambda 计算新值
        int beforeUpdate = atomicInt.getAndUpdate(x -> x * 2);
        // beforeUpdate = 70, value = 140
 
        // updateAndGet(UnaryOperator)：先用 lambda 计算新值，再获取
        int afterUpdate = atomicInt.updateAndGet(x -> x / 2);
        // afterUpdate = 70, value = 70
 
        // getAndAccumulate(x, BinaryOperator)：先获取旧值，再用二元运算符计算
        int beforeAcc = atomicInt.getAndAccumulate(3, (prev, x) -> prev * x);
        // beforeAcc = 70, value = 210
 
        // accumulateAndGet(x, BinaryOperator)：先计算再获取
        int afterAcc = atomicInt.accumulateAndGet(2, (prev, x) -> prev + x);
        // afterAcc = 212, value = 212
 
        System.out.println("Final value: " + atomicInt.get()); // 212
    }
}

// AtomicInteger.getAndIncrement() 源码
public final int getAndIncrement() {
    // 调用 Unsafe 的 getAndAddInt 方法
    // this：当前 AtomicInteger 对象
    // valueOffset：value 字段的内存偏移量
    // 1：增量值
    return unsafe.getAndAddInt(this, valueOffset, 1);
}
 
// Unsafe.getAndAddInt() 源码（JDK 8+）
public final int getAndAddInt(Object obj, long offset, int delta) {
    int expected;  // 期望值（即当前内存中的实际值）
    do {
        // 从内存中读取最新值（volatile 语义）
        expected = this.getIntVolatile(obj, offset);
        // CAS 尝试：如果内存值仍然是 expected，则更新为 expected + delta
        // 如果失败（说明其他线程已修改），则重新读取并再次尝试 → 自旋
    } while (!this.compareAndSwapInt(obj, offset, expected, expected + delta));
    // 循环结束说明 CAS 成功，返回旧值
    return expected;
}

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.CountDownLatch;
 
public class SafeCounter {
    // 使用 AtomicInteger 替代普通 int，天然线程安全
    private final AtomicInteger count = new AtomicInteger(0);
 
    // 递增操作，无需 synchronized，无需 lock
    public void increment() {
        count.incrementAndGet();
    }
 
    // 获取当前计数
    public int getCount() {
        return count.get();
    }
 
    public static void main(String[] args) throws InterruptedException {
        SafeCounter counter = new SafeCounter();
        int threadCount = 100;           // 100 个线程
        int perThread = 10000;           // 每个线程递增 10000 次
        CountDownLatch latch = new CountDownLatch(threadCount);
 
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                for (int j = 0; j < perThread; j++) {
                    counter.increment(); // 原子递增
                }
                latch.countDown();       // 当前线程完成
            }).start();
        }
 
        latch.await();                   // 等待所有线程结束
        // 结果一定是 1000000，不会出现丢失更新
        System.out.println("Final count: " + counter.getCount());
    }
}

import java.util.concurrent.atomic.AtomicLong;
 
public class AtomicLongDemo {
    // 典型场景：全局唯一 ID 生成器
    private static final AtomicLong ID_GENERATOR = new AtomicLong(0);
 
    // 每次调用都会返回一个全局唯一的、递增的 long 值
    public static long nextId() {
        return ID_GENERATOR.incrementAndGet();
    }
 
    public static void main(String[] args) {
        // 并发环境下也绝不会产生重复 ID
        System.out.println(nextId()); // 1
        System.out.println(nextId()); // 2
        System.out.println(nextId()); // 3
    }
}

// AtomicBoolean 源码核心
public class AtomicBoolean implements java.io.Serializable {
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;
    // 注意：底层存储的是 int 而非 boolean
    private volatile int value;
 
    // 构造方法：将 boolean 映射为 0 或 1
    public AtomicBoolean(boolean initialValue) {
        value = initialValue ? 1 : 0;
    }
 
    // get()：将 int 映射回 boolean
    public final boolean get() {
        return value != 0;
    }
 
    // compareAndSet：底层调用的是 compareAndSwapInt
    public final boolean compareAndSet(boolean expect, boolean update) {
        int e = expect ? 1 : 0;  // boolean → int
        int u = update ? 1 : 0;  // boolean → int
        return unsafe.compareAndSwapInt(this, valueOffset, e, u);
    }
}

import java.util.concurrent.atomic.AtomicBoolean;
 
public class OneTimeInitializer {
    // 初始化标志，初始为 false
    private final AtomicBoolean initialized = new AtomicBoolean(false);
 
    public void initialize() {
        // compareAndSet 是原子操作：只有一个线程能将 false 改为 true 并返回 true
        // 其他线程看到的已经是 true，CAS 失败，直接跳过
        if (initialized.compareAndSet(false, true)) {
            // 只有第一个成功的线程会进入这里
            System.out.println(Thread.currentThread().getName() + " 执行了初始化！");
            doHeavyInit();
        } else {
            System.out.println(Thread.currentThread().getName() + " 跳过初始化，已由其他线程完成");
        }
    }
 
    private void doHeavyInit() {
        // 模拟耗时初始化操作
        try { Thread.sleep(1000); } catch (InterruptedException e) { }
        System.out.println("初始化完成！");
    }
 
    public static void main(String[] args) {
        OneTimeInitializer initializer = new OneTimeInitializer();
        // 10 个线程同时尝试初始化
        for (int i = 0; i < 10; i++) {
            new Thread(initializer::initialize, "Thread-" + i).start();
        }
    }
}

import java.util.concurrent.atomic.AtomicIntegerArray;
 
public class AtomicIntegerArrayDemo {
    public static void main(String[] args) throws InterruptedException {
        // 方式一：指定数组长度，所有元素默认为 0
        AtomicIntegerArray arr1 = new AtomicIntegerArray(5);
 
        // 方式二：传入已有数组（注意：会复制一份，修改原数组不影响 AtomicIntegerArray）
        int[] source = {10, 20, 30, 40, 50};
        AtomicIntegerArray arr2 = new AtomicIntegerArray(source);
 
        // get(index)：获取索引位置的值
        System.out.println(arr2.get(0));             // 10
 
        // set(index, newValue)：设置索引位置的值
        arr2.set(0, 100);                            // arr2[0] = 100
 
        // getAndIncrement(index)：原子递增指定索引的值
        int old = arr2.getAndIncrement(1);           // old = 20, arr2[1] = 21
 
        // compareAndSet(index, expect, update)：CAS 更新指定索引
        boolean ok = arr2.compareAndSet(2, 30, 300); // ok = true, arr2[2] = 300
 
        // getAndUpdate(index, UnaryOperator)：函数式更新
        arr2.getAndUpdate(3, x -> x * 10);           // arr2[3] = 400
 
        // 修改原数组不影响 AtomicIntegerArray（因为构造时做了深拷贝）
        source[4] = 999;
        System.out.println(arr2.get(4));              // 仍然是 50，不受影响
 
        // 打印数组当前状态
        System.out.println(arr2);  // [100, 21, 300, 400, 50]
    }
}

// AtomicIntegerArray 构造方法源码
public AtomicIntegerArray(int[] array) {
    // clone() 创建了一份独立的副本
    // 外部对原始 array 的修改不会影响这里
    this.array = array.clone();
}

// AtomicIntegerArray 底层关键源码
private static final Unsafe unsafe = Unsafe.getUnsafe();
// 数组第一个元素的起始偏移量（对象头之后的位置）
private static final int base = unsafe.arrayBaseOffset(int[].class);
// 数组每个元素的字节大小（int 为 4 字节）
private static final int shift;
 
static {
    // scale = 4（int 占 4 字节）
    int scale = unsafe.arrayIndexScale(int[].class);
    // 计算 shift 值：4 = 2^2，所以 shift = 2
    // 通过位移代替乘法提升性能：offset = base + (i << shift)
    shift = 31 - Integer.numberOfLeadingZeros(scale);
}
 
// 计算第 i 个元素的偏移量
private long checkedByteOffset(int i) {
    // 边界检查
    if (i < 0 || i >= array.length)
        throw new IndexOutOfBoundsException("index " + i);
    return byteOffset(i);
}
 
private static long byteOffset(int i) {
    // base + i * 4  等价于  base + (i << 2)
    return ((long) i << shift) + base;
}

import java.util.concurrent.atomic.AtomicLongArray;
import java.util.concurrent.CountDownLatch;
 
public class MultiBucketCounter {
    // 10 个统计桶，分别统计不同类别的计数
    private final AtomicLongArray buckets = new AtomicLongArray(10);
 
    // 对第 bucketIndex 个桶原子递增
    public void increment(int bucketIndex) {
        buckets.getAndIncrement(bucketIndex);
    }
 
    // 获取所有桶的总和
    public long totalCount() {
        long sum = 0;
        for (int i = 0; i < buckets.length(); i++) {
            sum += buckets.get(i);           // 逐桶累加
        }
        return sum;
    }
 
    // 打印每个桶的值
    public void printBuckets() {
        System.out.println(buckets);
    }
 
    public static void main(String[] args) throws InterruptedException {
        MultiBucketCounter counter = new MultiBucketCounter();
        int threadCount = 50;
        CountDownLatch latch = new CountDownLatch(threadCount);
 
        for (int t = 0; t < threadCount; t++) {
            new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    // 随机选择一个桶进行递增
                    int bucket = (int) (Math.random() * 10);
                    counter.increment(bucket);
                }
                latch.countDown();
            }).start();
        }
 
        latch.await();
        counter.printBuckets();
        // 总计一定是 50 * 10000 = 500000
        System.out.println("Total: " + counter.totalCount());
    }
}

import java.util.concurrent.atomic.AtomicReferenceArray;
 
public class AtomicReferenceArrayDemo {
    public static void main(String[] args) {
        // 创建一个长度为 3 的引用类型原子数组
        AtomicReferenceArray<String> arr = new AtomicReferenceArray<>(3);
 
        // 设置初始值
        arr.set(0, "Alice");    // arr[0] = "Alice"
        arr.set(1, "Bob");      // arr[1] = "Bob"
        arr.set(2, "Charlie");  // arr[2] = "Charlie"
 
        // CAS 更新：只有当 arr[1] 还是 "Bob" 时，才替换为 "David"
        boolean success = arr.compareAndSet(1, "Bob", "David");
        System.out.println("CAS result: " + success); // true
        System.out.println("arr[1] = " + arr.get(1)); // David
 
        // getAndSet：原子交换
        String oldVal = arr.getAndSet(2, "Eve");
        System.out.println("Old: " + oldVal);          // Charlie
        System.out.println("New: " + arr.get(2));      // Eve
 
        // 函数式更新
        arr.updateAndGet(0, name -> name.toUpperCase());
        System.out.println("arr[0] = " + arr.get(0));  // ALICE
    }
}

import java.util.concurrent.atomic.AtomicReference;
 
// 不可变配置对象
class AppConfig {
    final String dbUrl;      // 数据库连接地址
    final int maxConnections; // 最大连接数
 
    AppConfig(String dbUrl, int maxConnections) {
        this.dbUrl = dbUrl;
        this.maxConnections = maxConnections;
    }
 
    @Override
    public String toString() {
        return "AppConfig{dbUrl='" + dbUrl + "', maxConn=" + maxConnections + "}";
    }
}
 
public class AtomicReferenceDemo {
    // 全局配置引用，使用 AtomicReference 保证原子替换
    private static final AtomicReference<AppConfig> CONFIG =
            new AtomicReference<>(new AppConfig("jdbc:mysql://localhost:3306/db", 10));
 
    // 热更新配置：原子地替换整个配置对象
    public static void updateConfig(String newUrl, int newMaxConn) {
        AppConfig oldConfig;
        AppConfig newConfig;
        do {
            // 读取当前配置
            oldConfig = CONFIG.get();
            // 构建新配置（不可变对象，线程安全）
            newConfig = new AppConfig(newUrl, newMaxConn);
            // CAS：只有当前配置未被其他线程修改时才替换
        } while (!CONFIG.compareAndSet(oldConfig, newConfig));
        System.out.println("Config updated: " + newConfig);
    }
 
    // 读取配置：无需加锁，直接读取引用
    public static AppConfig getConfig() {
        return CONFIG.get();
    }
 
    public static void main(String[] args) {
        System.out.println("Before: " + getConfig());
        updateConfig("jdbc:mysql://prod-server:3306/db", 50);
        System.out.println("After: " + getConfig());
    }
}

// AtomicStampedReference 源码核心
public class AtomicStampedReference<V> {
 
    // 内部类：将引用和版本号打包成一个不可变的 Pair 对象
    private static class Pair<T> {
        final T reference;    // 实际引用
        final int stamp;      // 版本号
        private Pair(T reference, int stamp) {
            this.reference = reference;
            this.stamp = stamp;
        }
        static <T> Pair<T> of(T reference, int stamp) {
            return new Pair<T>(reference, stamp);
        }
    }
 
    // 持有一个 volatile 的 Pair 引用
    // CAS 操作的目标就是这个 pair 引用
    private volatile Pair<V> pair;
 
    // 构造方法：传入初始引用和初始版本号
    public AtomicStampedReference(V initialRef, int initialStamp) {
        pair = Pair.of(initialRef, initialStamp);
    }
}

public boolean compareAndSet(V expectedReference,   // 期望的引用
                             V newReference,         // 新的引用
                             int expectedStamp,      // 期望的版本号
                             int newStamp) {         // 新的版本号
    Pair<V> current = pair;                          // 获取当前 Pair
    return
        expectedReference == current.reference &&    // 引用必须匹配
        expectedStamp == current.stamp &&            // 版本号必须匹配
        ((newReference == current.reference &&       // 如果新值与当前值完全相同
          newStamp == current.stamp) ||              // 则无需 CAS（短路优化）
         casPair(current, Pair.of(newReference, newStamp))); // 否则 CAS 替换 Pair
}
 
// 底层 CAS：对 pair 引用进行原子替换
private boolean casPair(Pair<V> cmp, Pair<V> val) {
    return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
}

import java.util.concurrent.atomic.AtomicStampedReference;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.TimeUnit;
 
public class ABADemo {
 
    // ========== 场景1：AtomicReference 无法检测 ABA ==========
    static AtomicReference<String> atomicRef = new AtomicReference<>("A");
 
    // ========== 场景2：AtomicStampedReference 成功检测 ABA ==========
    // 初始引用 "A"，初始版本号 1
    static AtomicStampedReference<String> stampedRef =
            new AtomicStampedReference<>("A", 1);
 
    public static void main(String[] args) throws InterruptedException {
        System.out.println("===== AtomicReference（存在 ABA 问题）=====");
        testAtomicReference();
 
        Thread.sleep(2000);
        System.out.println("\n===== AtomicStampedReference（解决 ABA）=====");
        testStampedReference();
    }
 
    static void testAtomicReference() throws InterruptedException {
        // 干扰线程：执行 A → B → A 的修改
        Thread interferor = new Thread(() -> {
            // A → B
            atomicRef.compareAndSet("A", "B");
            System.out.println("干扰线程: A -> B");
            // B → A（又改回去了！）
            atomicRef.compareAndSet("B", "A");
            System.out.println("干扰线程: B -> A");
        }, "interferor");
 
        // 业务线程：读取 A，然后尝试改为 C
        Thread worker = new Thread(() -> {
            String snapshot = atomicRef.get();        // 读到 "A"
            System.out.println("业务线程: 读取到 " + snapshot);
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {} // 等待干扰完成
            // CAS：期望 "A"，更新为 "C"
            boolean result = atomicRef.compareAndSet(snapshot, "C");
            // 结果为 true！ABA 问题发生了——虽然值回到了 A，但中间发生了变化
            System.out.println("业务线程: CAS result = " + result + ", value = " + atomicRef.get());
        }, "worker");
 
        interferor.start();
        Thread.sleep(100); // 确保干扰线程先执行
        worker.start();
        interferor.join();
        worker.join();
    }
 
    static void testStampedReference() throws InterruptedException {
        // 干扰线程：执行 A → B → A，每次修改都递增版本号
        Thread interferor = new Thread(() -> {
            int stamp = stampedRef.getStamp();         // stamp = 1
            // A → B, stamp 1 → 2
            stampedRef.compareAndSet("A", "B", stamp, stamp + 1);
            System.out.println("干扰线程: A -> B, stamp: " + stampedRef.getStamp());
 
            stamp = stampedRef.getStamp();             // stamp = 2
            // B → A, stamp 2 → 3
            stampedRef.compareAndSet("B", "A", stamp, stamp + 1);
            System.out.println("干扰线程: B -> A, stamp: " + stampedRef.getStamp());
        }, "interferor");
 
        // 业务线程：读取引用和版本号
        Thread worker = new Thread(() -> {
            String snapshot = stampedRef.getReference(); // "A"
            int stamp = stampedRef.getStamp();           // stamp = 1
            System.out.println("业务线程: 读取到 " + snapshot + ", stamp = " + stamp);
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {}
            // CAS：期望引用 "A" + 版本号 1
            boolean result = stampedRef.compareAndSet(snapshot, "C", stamp, stamp + 1);
            // 结果为 false！因为版本号已经从 1 变成了 3
            System.out.println("业务线程: CAS result = " + result
                    + ", value = " + stampedRef.getReference()
                    + ", stamp = " + stampedRef.getStamp());
        }, "worker");
 
        interferor.start();
        Thread.sleep(100);
        worker.start();
        interferor.join();
        worker.join();
    }
}

// 获取引用和版本号（通过 int[] 输出参数）
int[] stampHolder = new int[1];
String ref = stampedRef.get(stampHolder);
// ref = 当前引用，stampHolder[0] = 当前版本号
 
// attemptStamp：如果当前引用等于 expectedRef，则仅更新版本号
// 用于"只打标记不改引用"的场景
boolean stamped = stampedRef.attemptStamp("A", 100);

// AtomicMarkableReference 内部结构
private static class Pair<T> {
    final T reference;    // 实际引用
    final boolean mark;   // 标记位（true/false）
    private Pair(T reference, boolean mark) {
        this.reference = reference;
        this.mark = mark;
    }
}