决战超越并发瓶颈---解决并发难题

 转载来自于张彦峰ZYF大佬的：超越并发瓶颈：CAS与乐观锁的智慧应用_系统自动流转-优快云博客

s态和内核态的频繁切换，从而影响性能。

而Lock（如 ReentrantLock）是基于 AQS 实现，通过使用自旋锁和非阻塞算法，减少了用户态和内核态的切换，提高了性能。

​与 synchronized 的实现方式不同，AQS中很多数据结构的变化，都是依赖 CAS 进行操作的，而CAS 就是乐观锁的一种实现。

一、走进CAS

这里我们直接简单理解即可，如果想深入可见：揭秘CAS：深入理解与应用解析-优快云博客。

（一）基本知识快速回顾

CAS（Compare And Swap）技术是一种常用的并发编程技术，用于解决多线程环境下的数据竞争问题。它是无锁（lock-free）算法的一种实现方式，通过原子操作实现了线程安全的数据更新。

CAS操作通常包括三个参数：内存地址（或变量），期望值和新值。

​它的执行过程如下：

• 比较：CAS操作首先比较内存地址中的值与期望值是否相等。
• 交换：如果相等，CAS操作将新值写入内存地址，否则不进行任何操作。
• 返回：CAS操作返回内存地址中的旧值。

CAS操作在执行过程中具有原子性，即在比较和交换的过程中不会被其他线程干扰。这样可以确保多线程环境下数据的一致性和正确性。

分类	具体说明	解释
优点	无锁特性	CAS操作不需要使用传统的锁机制，避免了锁带来的开销和竞争问题，提高了并发性能和可伸缩性。
	原子性	CAS操作是原子的，不会发生线程间的竞争和数据不一致的问题。
	适用范围广	CAS操作可以用于实现各种同步原语和数据结构，如原子操作、乐观锁、无锁队列等。
缺点	ABA问题	CAS操作无法检测到其他线程在执行过程中对值的修改。例如，一个值原先是A，然后被修改为B，最后又被修改回A，这时CAS操作无法区分这种情况，会错误地认为值没有被修改过。
	自旋开销	如果CAS操作失败，会进入自旋状态，不断重试直到成功。自旋会占用CPU资源，当自旋次数过多时，会导致性能下降。
	并发度限制	CAS操作在并发度较高的情况下，由于竞争激烈，可能会导致大量的CAS操作失败，进而影响性能。

在实际应用中，CAS技术常用于实现线程安全的数据结构和算法，例如并发队列、计数器、自旋锁等。它在一些高并发场景下能够提供较好的性能和可伸缩性，但需要注意处理ABA问题和合理控制自旋次数，以及根据具体场景评估并发度的限制。

（二）CAS 的原子性实际上是硬件 CPU 直接保证的

直接以AtomicInteger 中 CAS 操作的原子性保证来进行理解。

Java 层次

AtomicInteger 类中的 compareAndSet 方法用于执行 CAS 操作，其代码如下：

public final boolean compareAndSet(int expectedValue, int newValue) {
    return U.compareAndSetInt(this, VALUE, expectedValue, newValue);
}

这里的 U 是 Unsafe 类的实例，VALUE 是内存偏移量。compareAndSetInt 是 Unsafe 类中的一个本地方法，直接调用底层的硬件指令来实现原子操作。

public final native boolean compareAndSetInt(Object o, long offset, int expected, int x);

JVM 层次

Unsafe 类中 compareAndSetInt 方法的实现会调用 weakCompareAndSetInt 方法，该方法通过自旋重试实现CAS操作：

public final int getAndAddInt(Object o, long offset, int delta) {
    int v;
    do {
        v = getIntVolatile(o, offset);
    } while (!weakCompareAndSetInt(o, offset, v, v + delta));
    return v;
}

在这个方法中，getIntVolatile 获取当前值，weakCompareAndSetInt 尝试更新值，如果更新失败，则重复上述过程，直到成功，即自旋重试。

硬件层次

在 Linux 系统的 x86 架构上，CAS 操作最终会映射到 cmpxchgl 汇编指令，这是由 os_cpu/linux_x86/atomic_linux_x86.hpp 文件中的代码实现的：

template<>
template<typename T>
inline T Atomic::PlatformCmpxchg<4>::operator()(T exchange_value,
                                                T volatile* dest,
                                                T compare_value,
                                                atomic_memory_order /* order */) const {
    STATIC_ASSERT(4 == sizeof(T));
    __asm__ volatile ("lock cmpxchgl %1,(%3)"
                      : "=a" (exchange_value)
                      : "r" (exchange_value), "a" (compare_value), "r" (dest)
                      : "cc", "memory");
    return exchange_value;
}

这里的 cmpxchgl 指令是关键。这条汇编指令的作用是：

• 比较寄存器 EAX 中的值（compare_value）和内存地址 dest 中的值。
• 如果两者相等，则将 exchange_value 存储到 dest 中。
• 如果不相等，则将 dest 中的值加载到 EAX 中。

lock 前缀确保了操作的原子性，这意味着在多处理器系统中，该指令在执行时会锁住总线或使用缓存一致性协议，保证其他处理器不能访问内存地址，直到操作完成。

在不同的硬件平台上，支持CAS操作的指令可能不同，但其基本原理是一致的：

• x86 平台：x86处理器提供了 CMPXCHG 指令来实现CAS操作。这个指令是原子的，即在执行过程中，不会被其他指令中断。
• PowerPC 平台：PowerPC处理器提供了 lwarx 和 stwcx. 指令组合来实现CAS操作，这些指令也确保了操作的原子性。
• ARM 平台：ARM处理器提供了 LDREX 和 STREX 指令组合来实现CAS操作。

总结

硬件指令 cmpxchgl 结合 lock 前缀保证了在多处理器环境下的原子性，即整个比较和替换操作是不可分割的，这就是 CAS 操作能够实现原子性的原因。

（三）性能检测说明

为了验证原子类的性能优势，可以编写一个简单的测试程序，分别使用 AtomicInteger（CAS 实现）和 synchronized 关键字来实现一个计数器，并进行多线程并发访问，最后比较它们的性能。具体代码如下：

package org.zyf.javabasic.thread.lock.opti;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @program: zyfboot-javabasic
 * @description: 比较使用 AtomicInteger 和 synchronized 关键字的性能
 * @author: zhangyanfeng
 * @create: 2024-06-08 11:10
 **/
public class AtomicVsSynchronized {
    private static final int THREAD_COUNT = 100;
    private static final int ITERATIONS = 1000000;

    // 使用 AtomicInteger 实现计数器
    private static AtomicInteger atomicCounter = new AtomicInteger(0);

    // 使用 synchronized 实现计数器
    private static int synchronizedCounter = 0;

    // 使用 AtomicInteger 进行计数
    private static class AtomicCounterRunnable implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < ITERATIONS; i++) {
                atomicCounter.incrementAndGet();
            }
        }
    }

    // 使用 synchronized 进行计数
    private static class SynchronizedCounterRunnable implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < ITERATIONS; i++) {
                synchronized (AtomicVsSynchronized.class) {
                    synchronizedCounter++;
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        long startTime;
        long endTime;

        // 测试使用 AtomicInteger 的性能
        startTime = System.currentTimeMillis();
        Thread[] atomicThreads = new Thread[THREAD_COUNT];
        for (int i = 0; i < THREAD_COUNT; i++) {
            atomicThreads[i] = new Thread(new AtomicCounterRunnable());
            atomicThreads[i].start();
        }
        for (int i = 0; i < THREAD_COUNT; i++) {
            atomicThreads[i].join();
        }
        endTime = System.currentTimeMillis();
        System.out.println("AtomicInteger 总耗时：" + (endTime - startTime) + " 毫秒");
        System.out.println("AtomicInteger 计数结果：" + atomicCounter.get());

        // 测试使用 synchronized 的性能
        startTime = System.currentTimeMillis();
        Thread[] syncThreads = new Thread[THREAD_COUNT];
        for (int i = 0; i < THREAD_COUNT; i++) {
            syncThreads[i] = new Thread(new SynchronizedCounterRunnable());
            syncThreads[i].start();
        }
        for (int i = 0; i < THREAD_COUNT; i++) {
            syncThreads[i].join();
        }
        endTime = System.currentTimeMillis();
        System.out.println("synchronized 总耗时：" + (endTime - startTime) + " 毫秒");
        System.out.println("synchronized 计数结果：" + synchronizedCounter);
    }
}

运行结果如下：

• AtomicInteger 总耗时：6754 毫秒 ，AtomicInteger 计数结果：100000000
• synchronized 总耗时：2409 毫秒，synchronized 计数结果：100000000

数据说明使用 synchronized 关键字的方式比使用 AtomicInteger 类的方式具有更好的性能。

二、理解乐观锁