// 基于 JDK 17 本地源码, java.util.concurrent.atomic.AtomicInteger
public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    /*
     * This class intended to be implemented using VarHandles, but there
     * are unresolved cyclic startup dependencies.
     */
    private static final Unsafe U = Unsafe.getUnsafe();   // 官方推荐用户代码用 VarHandle, 它自己却用 Unsafe: VarHandle 初始化本身就依赖原子操作, 启动期有循环依赖
    private static final long VALUE
        = U.objectFieldOffset(AtomicInteger.class, "value");   // value 字段相对对象基址的偏移量, 类加载时算一次。CAS 是内存地址级操作, 靠"基址+偏移"定位那 4 字节

    private volatile int value;   // volatile 管可见性, CAS 管原子性, 缺一个都不线程安全

    public AtomicInteger(int initialValue) {
        value = initialValue;   // 构造期无竞争, 普通写即可
    }

    // ...

    public final int get() {
        return value;   // 普通读的正确性全靠 value 的 volatile 修饰, 不经过 Unsafe
    }

    public final void set(int newValue) {
        value = newValue;   // 单纯覆盖不需要 CAS: 没有"依赖旧值"就没有竞态
    }

    public final void lazySet(int newValue) {
        U.putIntRelease(this, VALUE, newValue);   // release 语义: 省掉最贵的 StoreLoad 屏障, 新值稍后才对别的线程可见, 适合"清空引用"这类不急的写
    }

    // ...

    public final boolean compareAndSet(int expectedValue, int newValue) {
        return U.compareAndSetInt(this, VALUE, expectedValue, newValue);   // CAS 核心入口: "当前值==期望值才写入"整体是一条 CPU 指令, 不可打断
    }

    // ...

    public final int getAndIncrement() {
        return U.getAndAddInt(this, VALUE, 1);   // i++ 语义, 返回旧值
    }

    // ...

    public final int getAndAdd(int delta) {
        return U.getAndAddInt(this, VALUE, delta);
    }

    public final int incrementAndGet() {
        return U.getAndAddInt(this, VALUE, 1) + 1;   // ++i 语义。硬件只提供"返回旧值"的 fetch-and-add, 新值在本地 +1 算出, 绝不能再读一次内存(可能已被别人改)
    }

    // ...

    public final int addAndGet(int delta) {
        return U.getAndAddInt(this, VALUE, delta) + delta;
    }

    // ...

    public final int updateAndGet(IntUnaryOperator updateFunction) {
        int prev = get(), next = 0;
        for (boolean haveNext = false;;) {
            if (!haveNext)
                next = updateFunction.applyAsInt(prev);   // 竞争下函数会被反复执行, 所以要求它无副作用
            if (weakCompareAndSetVolatile(prev, next))
                return next;
            haveNext = (prev == (prev = get()));   // 重读后值没变 => 刚才是 weak CAS 的"伪失败", next 仍有效, 下一轮跳过重算
        }
    }

    // ...

    public final int compareAndExchange(int expectedValue, int newValue) {
        return U.compareAndExchangeInt(this, VALUE, expectedValue, newValue);   // 返回"见证值"(内存里实际的值): CAS 失败时不用再 get() 一次就知道输给了谁
    }

    // ...
}

// 基于 JDK 17 本地源码, jdk.internal.misc.Unsafe
public final class Unsafe {

    // ...

    @IntrinsicCandidate
    public final int getAndAddInt(Object o, long offset, int delta) {
        int v;
        do {
            v = getIntVolatile(o, offset);   // 每轮重读最新值; CAS 失败说明这一瞬间有人抢先改了, 拿旧值重试必然再败
        } while (!weakCompareAndSetInt(o, offset, v, v + delta));
        return v;   // 返回自增前的旧值
    }

    // ...

    @IntrinsicCandidate
    public final boolean weakCompareAndSetInt(Object o, long offset,
                                              int expected,
                                              int x) {
        return compareAndSetInt(o, offset, expected, x);   // Java 层兜底直接转调强 CAS; "weak 允许伪失败"的差别只在 JIT 内在化后的机器码里体现
    }

    // ...

    @IntrinsicCandidate
    public final native boolean compareAndSetInt(Object o, long offset,
                                                 int expected,
                                                 int x);   // 到底了: x86 上就是 lock cmpxchg 一条指令

    // ...
}