理解 CAS & Atomic 原子操作类

1. CAS介绍

什么是CAS

CAS（Compare And Swap，比较与交换），是非阻塞同步的实现原理，它是 CPU 硬件层面的一种指令，从 CPU 层面能保证"比较与交换"两个操作的原子性。

CAS 指令操作包括三个参数：

• 内存值（内存地址值）V
• 预期值 E
• 新值 N

当 CAS 指令执行时，当且仅当预期值 E 和内存值 V 相同时，才更新内存值为 N，否则就不执行更新。无论更新与否都会返回旧的内存值 V，上述的处理过程是一个原子操作。

用 Java 代码等效实现一下 CAS 的执行过程：

public class CASDemo {

    // 内存中当前的值
    private volatile int ramAddress;

    /**
     * @param expectedValue 期望值
     * @param newValue 更新的值
     **/
    public synchronized int compareAndSwap(int expectedValue, int newValue) {
        //TODO 模拟直接从内存地址读取到内存中的值
        int oldRamAddress = accessMemory(ramAddress);
        // 内存中的值和期望的值进行比较
        if (oldRamAddress == expectedValue) {
            ramAddress = newValue;
        }
        return oldRamAddress;
    }

    private int accessMemory(int ramAddress) {
        //TODO 模拟直接从内存地址读取到内存中的值
        return ramAddress;
    }
}

以上伪代码描述了一个由比较和赋值两阶段组成的复合操作，CAS 可以看作是它们合并后的整体，一个不可分割的原子操作，并且其原子性是直接在硬件层面 得到保障的。CAS 是一种无锁算法 ，在不使用锁（没有线程被阻塞）的情况下实现多线程之间的变量同步。CAS 可以看做是乐观锁的一种实现方式，Java 原子类中的递增操作就通过 CAS 自旋实现的。

---

CAS在Java中的使用

在 Java 中，CAS 操作是由 Unsafe 类提供支持的，该类定义了三种针对不同类型变量的 CAS 操作：

// 它们都是 native 方法
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

Unsafe 是位于 sun.misc 包下的一个类，主要提供一些用于执行低级别、不安全操作的方法，如直接访问系统内存资源、自主管理内存资源等。但这些方法在提升 Java 运行效率的同时，也使 Java 语言拥有了类似 C 语言指针一样操作内存空间的能力，增加了程序出错的风险，因此对 Unsafe 的使用一定要慎重。

以 compareAndSwapInt 为例，Unsafe 的 compareAndSwapInt 方法接收 4 个参数：

参数	说明
对象实例	需要操作的对象
内存偏移量	字段在对象内存中的偏移地址
字段期望值	期望的当前值
字段新值	要更新的值

CAS 使用示例：

public class CASTest {

    public static void main(String[] args) {
        Entity entity = new Entity();

        Unsafe unsafe = UnsafeFactory.getUnsafe();
        long offset = UnsafeFactory.getFieldOffset(unsafe, Entity.class, "x");

        boolean successful;
        // 4个参数分别是：对象实例、字段的内存偏移量、字段期望值、字段新值
        successful = unsafe.compareAndSwapInt(entity, offset, 0, 3);
        System.out.println(successful + "\t" + entity.x);

        successful = unsafe.compareAndSwapInt(entity, offset, 3, 5);
        System.out.println(successful + "\t" + entity.x);

        successful = unsafe.compareAndSwapInt(entity, offset, 3, 8);
        System.out.println(successful + "\t" + entity.x);
    }
}

UnsafeFactory 工具类：

public class UnsafeFactory {

    /**
     * 获取 Unsafe 对象
     */
    public static Unsafe getUnsafe() {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            return (Unsafe) field.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取字段的内存偏移量
     */
    public static long getFieldOffset(Unsafe unsafe, Class clazz, String fieldName) {
        try {
            return unsafe.objectFieldOffset(clazz.getDeclaredField(fieldName));
        } catch (NoSuchFieldException e) {
            throw new Error(e);
        }
    }
}

测试结果： 针对 entity.x 的 3 次 CAS 操作，分别试图将它从 0 改成 3、从 3 改成 5、从 3 改成 8。

---

CAS应用场景

CAS 在 java.util.concurrent.atomic 相关类、Java AQS、ConcurrentHashMap 等实现上有非常广泛的应用。

如下图所示，AtomicInteger 的实现中，静态字段 valueOffset 即为字段 value 的内存偏移地址，valueOffset 的值在 AtomicInteger 初始化时，在静态代码块中通过 Unsafe 的 objectFieldOffset 方法获取。在 AtomicInteger 中提供的线程安全方法中，通过字段 valueOffset 的值可以定位到 AtomicInteger 对象中 value 的内存地址，从而可以根据 CAS 实现对 value 字段的原子操作。

（图：AtomicInteger 对象自增操作前后的内存示意图------对象的基地址 baseAddress，通过 baseAddress + valueOffset 得到 value 的内存地址，然后通过 CAS 进行原子性的更新操作）。下图为某个AtomicInteger对象自增操作前后的内存示意图，对象的基地址baseAddress="0x110000"，通过baseAddress+valueOffset得到value的内存地址valueAddress="0x11000c"；然后通过CAS进行原子性的更新操作，成功则返回，否则继续重试，直到更新成功为止。

---

2. CAS源码分析

Unsafe 层源码

Hotspot 虚拟机对 compareAndSwapInt 方法的实现如下：

// unsafe.cpp
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject
obj, jlong offset, jint e, jint x))
    UnsafeWrapper("Unsafe_CompareAndSwapInt");
    oop p = JNIHandles::resolve(obj);
    // 根据偏移量，计算value的地址
    jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
    // Atomic::cmpxchg(x, addr, e) cas逻辑 x:要交换的值   e:要比较的值
    // cas成功，返回期望值e，等于e,此方法返回true
    // cas失败，返回内存中的value值，不等于e，此方法返回false
    return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
UNSAFE_END2

核心逻辑在 Atomic::cmpxchg 方法中，这个根据不同操作系统和不同 CPU 会有不同的实现。以 linux_64x 为例：

// atomic_linux_x86.inline.hpp
inline jint Atomic::cmpxchg(jint exchange_value, volatile jint* dest,
                              jint compare_value) {
    // 判断当前执行环境是否为多处理器环境
    int mp = os::is_MP();
    // LOCK_IF_MP(%4) 在多处理器环境下，为 cmpxchgl 指令添加 lock 前缀，以达到内存屏障的效果
    // cmpxchgl 指令是包含在 x86 架构及 IA-64 架构中的一个原子条件指令
    __asm__ volatile (LOCK_IF_MP(%4) "cmpxchgl %1,(%3)"
                      : "=a" (exchange_value)
                      : "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp)
                      : "cc", "memory");
    return exchange_value;
}

Cmpxchgl指令详解

cmpxchgl 的详细执行过程：

1. compare_value 存入 eax 寄存器
2. exchange_value、dest、mp 的值存入任意的通用寄存器
3. 嵌入式汇编把输出和输入寄存器按统一顺序编号：输出的 eax 是 %0，输入的 exchange_value、compare_value、dest、mp 分别是 %1、%2、%3、%4
4. cmpxchg %1,(%3) 实际表示 cmpxchg exchange_value,(dest)
5. cmpxchg 有个隐含操作数 eax ：先比较 eax 的值（compare_value）和 dest 地址所存的值是否相等
   • 如果相等，则将 dest 指向的内存值变为 exchange_value，并将 eax（compare_value）作为返回值
   • 如果不相等，则将 dest 指向的内存值写入 eax，作为返回值

因此 (jint)(Atomic::cmpxchg(x, addr, e)) == e 为 true 表示 CAS 成功，false 表示 CAS 失败。

总结

现代处理器指令集架构基本上都会提供 CAS 指令，例如：

• x86 和 IA-64 架构中的 cmpxchgl 指令和 comxchgq 指令
• sparc 架构中的 cas 指令和 casx 指令

不管是 Hotspot 中的 Atomic::cmpxchg 方法，还是 Java 中的 compareAndSwapInt 方法，它们本质上都是对相应平台的 CAS 指令的一层简单封装 。CAS 指令作为一种硬件原语，有着天然的原子性，这正是 CAS 的价值所在。

---

3. CAS缺陷

CAS 虽然高效地解决了原子操作，但是还是存在一些缺陷的，主要表现在三个方面：

缺陷	说明
自旋开销大	自旋 CAS 长时间不成功，会给 CPU 带来非常大的开销
只能保证一个共享变量原子操作	无法同时对多个共享变量进行原子操作
ABA 问题	某个线程将值 A 修改为 B，又马上修改回 A，其他线程不感知

ABA问题及其解决方案

什么是ABA问题

当有多个线程对一个原子类进行操作的时候，某个线程在短时间内将原子类的值 A 修改为 B，又马上将其修改为 A，此时其他线程不感知，还是会修改成功。

ABA 问题演示：

@Slf4j
public class ABATest {

    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(1);

        new Thread(()->{
            int value = atomicInteger.get();
            log.debug("Thread1 read value: " + value);
            // 阻塞1s
            LockSupport.parkNanos(1000000000L);
            // Thread1通过CAS修改value值为3
            if (atomicInteger.compareAndSet(value, 3)) {
                log.debug("Thread1 update from " + value + " to 3");
            } else {
                log.debug("Thread1 update fail!");
            }
        },"Thread1").start();

        new Thread(()->{
            int value = atomicInteger.get();
            log.debug("Thread2 read value: " + value);
            // Thread2通过CAS修改value值为2
            if (atomicInteger.compareAndSet(value, 2)) {
                log.debug("Thread2 update from " + value + " to 2");
                // do something
                value = atomicInteger.get();
                log.debug("Thread2 read value: " + value);
                // Thread2通过CAS修改value值为1
                if (atomicInteger.compareAndSet(value, 1)) {
                    log.debug("Thread2 update from " + value + " to 1");
                }
            }
        },"Thread2").start();
    }
}

Thread1 不清楚 Thread2 对 value 的操作，误以为 value=1 没有修改过。

ABA问题的解决方案

数据库的乐观锁 基于数据版本实现数据同步，每次修改数据版本就会累加。同样，Java 也提供了相应的原子引用类 AtomicStampedReference<V> ，使用 reference（实际存储的变量）加 stamp（版本号）来保证每次修改后的版本也会往上递增。

使用 AtomicStampedReference 解决 ABA：

@Slf4j
public class AtomicStampedReferenceTest {

    public static void main(String[] args) {
        // 定义AtomicStampedReference Pair.reference值为1, Pair.stamp为1
        AtomicStampedReference atomicStampedReference = new AtomicStampedReference(1, 1);

        new Thread(()->{
            int[] stampHolder = new int[1];
            int value = (int) atomicStampedReference.get(stampHolder);
            int stamp = stampHolder[0];
            log.debug("Thread1 read value: " + value + ", stamp: " + stamp);
            // 阻塞1s
            LockSupport.parkNanos(1000000000L);
            // Thread1通过CAS修改value值为3，stamp+1
            if (atomicStampedReference.compareAndSet(value, 3, stamp, stamp+1)) {
                log.debug("Thread1 update from " + value + " to 3");
            } else {
                log.debug("Thread1 update fail!");
            }
        },"Thread1").start();

        new Thread(()->{
            int[] stampHolder = new int[1];
            int value = (int) atomicStampedReference.get(stampHolder);
            int stamp = stampHolder[0];
            log.debug("Thread2 read value: " + value + ", stamp: " + stamp);
            // Thread2通过CAS修改value值为2
            if (atomicStampedReference.compareAndSet(value, 2, stamp, stamp+1)) {
                log.debug("Thread2 update from " + value + " to 2");
                // do something
                value = (int) atomicStampedReference.get(stampHolder);
                stamp = stampHolder[0];
                log.debug("Thread2 read value: " + value + ", stamp: " + stamp);
                // Thread2通过CAS修改value值为1
                if (atomicStampedReference.compareAndSet(value, 1, stamp, stamp+1)) {
                    log.debug("Thread2 update from " + value + " to 1");
                }
            }
        },"Thread2").start();
    }
}

Thread1 并没有成功修改 value，因为 stamp 版本号已经变了。

补充： AtomicMarkableReference 是 AtomicStampedReference 的简化版，不关心修改过几次，仅仅关心是否修改过。变量 mark 是 boolean 类型，仅记录值是否有过修改。

---

4. Atomic原子操作类介绍

在并发编程中很容易出现并发安全的问题，多线程执行 i++ 操作就可能获取不到正确的值。J.U.C 下的 atomic 包提供了一系列操作简单、性能高效，并能保证线程安全的类去更新基本类型变量、数组元素、引用类型以及更新对象中的字段类型。atomic 包下的这些类采用的是乐观锁策略 去原子更新数据，在 Java 中则是使用 CAS 操作具体实现。

Atomic包类体系

类别	类名
基本类型	AtomicInteger、AtomicLong、AtomicBoolean
引用类型	AtomicReference、AtomicStampedReference、AtomicMarkableReference
数组类型	AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray
对象属性原子修改器	AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater
原子类型累加器（JDK1.8+）	DoubleAccumulator、DoubleAdder、LongAccumulator、LongAdder

---

原子更新基本类型 --- AtomicInteger

常用方法：

// 以原子的方式将实例中的原值加1，返回的是自增前的旧值
public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

// getAndSet(int newValue)：将实例中的值更新为新值，并返回旧值
public final boolean getAndSet(boolean newValue) {
    boolean prev;
    do {
        prev = get();
    } while (!compareAndSet(prev, newValue));
    return prev;
}

// incrementAndGet()：以原子的方式将实例中的原值进行加1操作，并返回最终相加后的结果
public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

// addAndGet(int delta)：以原子方式将输入的数值与实例中原本的值相加，并返回最后的结果
public final int addAndGet(int delta) {
    return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}

incrementAndGet() 方法通过 CAS 自增实现，如果 CAS 失败，自旋直到成功 +1。

思考：这种 CAS 失败自旋的操作存在什么问题？（引出 LongAdder）

AtomicInteger 使用示例：

public class AtomicIntegerTest {
    static AtomicInteger sum = new AtomicInteger(0);

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    // 原子自增 CAS
                    sum.incrementAndGet();
                }
            });
            thread.start();
        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(sum.get());
    }
}

---

原子更新数组类型 --- AtomicIntegerArray

常用方法：

// addAndGet(int i, int delta)：以原子更新的方式将数组中索引为i的元素与输入值相加
public final int addAndGet(int i, int delta) {
    return getAndAdd(i, delta) + delta;
}

// getAndIncrement(int i)：以原子更新的方式将数组中索引为i的元素自增加1
public final int getAndIncrement(int i) {
    return getAndAdd(i, 1);
}

// compareAndSet(int i, int expect, int update)：将数组中索引为i的位置的元素进行更新
public final boolean compareAndSet(int i, int expect, int update) {
    return compareAndSetRaw(checkedByteOffset(i), expect, update);
}

使用示例：

public class AtomicIntegerArrayTest {
    static int[] value = new int[]{ 1, 2, 3, 4, 5 };
    static AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(value);

    public static void main(String[] args) throws InterruptedException {
        // 设置索引0的元素为100
        atomicIntegerArray.set(0, 100);
        System.out.println(atomicIntegerArray.get(0));
        // 以原子更新的方式将数组中索引为1的元素与输入值相加
        atomicIntegerArray.getAndAdd(1, 5);
        System.out.println(atomicIntegerArray);
    }
}

---

原子更新引用类型 --- AtomicReference

AtomicReference 作用是对普通对象的封装，它可以保证你在修改对象引用时的线程安全性。

public class AtomicReferenceTest {

    public static void main(String[] args) {
        User user1 = new User("张三", 23);
        User user2 = new User("李四", 25);
        User user3 = new User("王五", 20);

        // 初始化为 user1
        AtomicReference<User> atomicReference = new AtomicReference<>();
        atomicReference.set(user1);

        // 把 user2 赋给 atomicReference
        atomicReference.compareAndSet(user1, user2);
        System.out.println(atomicReference.get());

        // 把 user3 赋给 atomicReference
        atomicReference.compareAndSet(user1, user3);
        System.out.println(atomicReference.get());
    }
}

@Data
@AllArgsConstructor
class User {
    private String name;
    private Integer age;
}

---

对象属性原子修改器 --- AtomicIntegerFieldUpdater

AtomicIntegerFieldUpdater 可以线程安全地更新对象中的整型变量。

public class AtomicIntegerFieldUpdaterTest {

    public static class Candidate {
        volatile int score = 0;
        AtomicInteger score2 = new AtomicInteger();
    }

    public static final AtomicIntegerFieldUpdater<Candidate> scoreUpdater =
            AtomicIntegerFieldUpdater.newUpdater(Candidate.class, "score");

    public static AtomicInteger realScore = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        final Candidate candidate = new Candidate();
        Thread[] t = new Thread[10000];
        for (int i = 0; i < 10000; i++) {
            t[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    if (Math.random() > 0.4) {
                        candidate.score2.incrementAndGet();
                        scoreUpdater.incrementAndGet(candidate);
                        realScore.incrementAndGet();
                    }
                }
            });
            t[i].start();
        }
        for (int i = 0; i < 10000; i++) {
            t[i].join();
        }
        System.out.println("AtomicIntegerFieldUpdater Score=" + candidate.score);
        System.out.println("AtomicInteger Score=" + candidate.score2.get());
        System.out.println("realScore=" + realScore.get());
    }
}

使用约束：

约束	说明
字段必须是 volatile 类型	保证线程间立即可见
字段描述类型一致	调用者必须能直接操作对象字段
只能是实例变量	不能加 static 关键字
不能是 final 变量	final 语义与 volatile 冲突
只能修改 int/long 类型	包装类型需使用 AtomicReferenceFieldUpdater

---

5. LongAdder / DoubleAdder 详解

为什么需要LongAdder

AtomicLong 是利用了底层的 CAS 操作来提供并发性的：

public final long addAndGet(long delta) {
    return unsafe.getAndAddLong(this, valueOffset, delta) + delta;
}

上述方法调用了 Unsafe 类的 getAndAddLong 方法，该方法内部是个 native 方法，逻辑是采用自旋的方式不断更新目标值，直到更新成功。

在并发量较低的环境下，线程冲突的概率比较小，自旋的次数不会很多。但是，高并发环境下 ，N 个线程同时进行自旋操作，会出现大量失败并不断自旋的情况，此时 AtomicLong 的自旋会成为瓶颈。这就是 LongAdder 引入的初衷------解决高并发环境下 AtomicInteger、AtomicLong 的自旋瓶颈问题。

性能测试

public class LongAdderTest {

    public static void main(String[] args) {
        testAtomicLongVSLongAdder(10, 10000);
        System.out.println("==================");
        testAtomicLongVSLongAdder(10, 200000);
        System.out.println("==================");
        testAtomicLongVSLongAdder(100, 200000);
    }

    static void testAtomicLongVSLongAdder(final int threadCount, final int times) {
        try {
            long start = System.currentTimeMillis();
            testLongAdder(threadCount, times);
            long end = System.currentTimeMillis() - start;
            System.out.println("条件>>>>>>线程数:" + threadCount + ", 单线程操作计数" + times);
            System.out.println("结果>>>>>>LongAdder方式增加计数" + (threadCount * times)
                                + "次,共计耗时:" + end);

            long start2 = System.currentTimeMillis();
            testAtomicLong(threadCount, times);
            long end2 = System.currentTimeMillis() - start2;
            System.out.println("条件>>>>>>线程数:" + threadCount + ", 单线程操作计数" + times);
            System.out.println("结果>>>>>>AtomicLong方式增加计数" + (threadCount * times)
                                + "次,共计耗时:" + end2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static void testAtomicLong(final int threadCount, final int times) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        AtomicLong atomicLong = new AtomicLong();
        for (int i = 0; i < threadCount; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < times; j++) {
                        atomicLong.incrementAndGet();
                    }
                    countDownLatch.countDown();
                }
            }, "my-thread" + i).start();
        }
        countDownLatch.await();
    }

    static void testLongAdder(final int threadCount, final int times) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        LongAdder longAdder = new LongAdder();
        for (int i = 0; i < threadCount; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < times; j++) {
                        longAdder.add(1);
                    }
                    countDownLatch.countDown();
                }
            }, "my-thread" + i).start();
        }
        countDownLatch.await();
    }
}

测试结果： 线程数越多，并发操作数越大，LongAdder 的优势越明显。低并发、一般的业务场景下 AtomicLong 足够了；如果并发量很多，存在大量写多读少的情况，LongAdder 可能更合适。

---

LongAdder原理

设计思路

AtomicLong 中有个内部变量 value 保存着实际的 long 值，所有的操作都是针对该变量进行。高并发环境下，value 变量其实是一个热点，也就是 N 个线程竞争一个热点。

LongAdder 的基本思路就是分散热点，将 value 值分散到一个数组中，不同线程会命中到数组的不同槽中，各个线程只对自己槽中的那个值进行 CAS 操作，这样热点就被分散了，冲突的概率就小很多。如果要获取真正的 long 值，只要将各个槽中的变量值累加返回。

（图：AtomicLong vs LongAdder 设计思路对比）

LongAdder的内部结构

/** Number of CPUS, to place bound on table size */
// CPU核数，用来决定槽数组的大小
static final int NCPU = Runtime.getRuntime().availableProcessors();

/**
 * Table of cells. When non-null, size is a power of 2.
 */
// 数组槽，大小为2的次幂
transient volatile Cell[] cells;

/**
 * Base value, used mainly when there is no contention, but also as
 * a fallback during table initialization races. Updated via CAS.
 *
 * 基数，在两种情况下会使用：
 * 1. 没有遇到并发竞争时，直接使用base累加数值
 * 2. 初始化cells数组时，必须要保证cells数组只能被初始化一次，
 *    其他竞争失败的线程会将数值累加到base上
 */
transient volatile long base;

/**
 * Spinlock (locked via CAS) used when resizing and/or creating Cells.
 */
transient volatile int cellsBusy;

成员	说明
base	非竞态条件下，直接累加到该变量上
Cell[]	竞态条件下，累加到各个线程自己的槽 Cell[i] 中
cellsBusy	自旋锁，用于扩容和创建 Cell 时的同步

LongAdder#add方法

只有从未出现过并发冲突的时候，base 基数才会使用到，一旦出现了并发冲突，之后所有的操作都只针对 Cell[] 数组中的单元 Cell。

• 如果 Cell[] 数组未初始化，会调用父类的 longAccumulate 去初始化 Cell[]
• 如果 Cell[] 已经初始化但是冲突发生在 Cell 单元内，也调用父类的 longAccumulate，此时可能就需要对 Cell\[\] 扩容了

这也是 LongAdder 设计的精妙之处：尽量减少热点冲突，不到最后万不得已，尽量将 CAS 操作延迟。

LongAdder#sum方法

/**
 * 返回累加的和，也就是"当前时刻"的计数值
 * 注意：高并发时，除非全局加锁，否则得不到程序运行中某个时刻绝对准确的值
 *       此返回值可能不是绝对准确的，因为调用这个方法时还有其他线程可能正在进行计数累加，
 *       方法的返回时刻和调用时刻不是同一个点，在有并发的情况下，这个值只是近似准确的计数值
 */
public long sum() {
    Cell[] as = cells; Cell a;
    long sum = base;
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

由于计算总和时没有对 Cell 数组进行加锁，所以在累加过程中可能有其他线程对 Cell 中的值进行了修改，也有可能对数组进行了扩容，所以 sum 返回的值并不是非常精确的。

---

AtomicLong vs LongAdder 总结

对比维度	AtomicLong	LongAdder
原理	单变量 CAS 自旋	分散热点（base + Cell\[\] 数组）
低并发	性能好	稍差（需要维护 Cell 数组）
高并发	自旋瓶颈，性能急剧下降	优势明显，冲突概率大幅降低
sum() 精确性	精确（单个变量）	近似值（无锁累加）
适用场景	并发量一般、需要精确值	高并发、写多读少