Java多线程系列——CAS机制

飞影铠甲

于 2024-02-21 09:30:33 发布

阅读量1.1k

点赞数 38

分类专栏： Java 文章标签： java 开发语言 c++ 算法数据结构

本文链接：https://blog.csdn.net/m0_63080216/article/details/136203196

版权

Java 专栏收录该内容

32 篇文章 3 订阅

订阅专栏

在并发编程的世界里，线程安全是个不得不面对的问题，而CAS（Compare-And-Swap，比较并交换）正是保障并发安全中一种非常关键的机制。本文将深入剖析Java多线程环境下的CAS机制，包括其工作原理、实现方式、面临的问题以及相关的优化策略，力求为读者带来全面的了解。

一、CAS的工作原理

CAS机制的核心在于“比较并交换”。这是一个不断循环的过程，它包含三个关键的操作数：“内存值”、"预期原值" 以及“新值”。具体工作流程是：首先，它会比较内存中某个变量的当前值与预期原值是否相等，如果相等，则说明在这段期间内该变量未被更改，此时就可以将该变量的值更改为"新值"。这整个操作是一个原子性操作。

细节

CAS操作在并发编程中是基于乐观锁的思想，假设在执行操作的时候不会发生冲突，先进行操作，如果发现有冲突再进行回滚。这与悲观锁（如synchronized锁定代码块）形成对比，悲观锁事先假定会有冲突发生，因此先加锁处理。

CPU指令支持

CAS依赖特定的CPU指令，如x86架构下的cmpxchg，这种硬件级别的支持使得CAS能够实现真正的原子操作。这是实现高效并发控制的关键。

Java底层应用

Java的Unsafe类提供了硬件级别的原子操作，但这些方法通常不对Java开发者公开。java.util.concurrent.atomic包中的原子类，如AtomicInteger，底层就是通过Unsafe类实现的。

工作流程

获取当前内存值。
计算新值。
使用CAS尝试写入新值（比较当前内存值与期望值，如果一致，则更新为新值）。
如果更新失败，则重复上述过程。

二、Java中的CAS实现

Java中的CAS操作是依赖原子类在并发环境下实现无锁的线程安全操作。在java.util.concurrent.atomic包中提供了一系列的原子类，例如AtomicInteger、AtomicLong、AtomicReference等。

以AtomicInteger为例，我们可以通过调用其compareAndSet(expect, update)方法来执行CAS操作。当期望值expect与变量的当前值相等时，就可以将这个变量设置为新值update。

示例代码

public class CASExample {
    private static final AtomicInteger atomicCount = new AtomicInteger(0);

    public static void increment() {
        int oldValue;
        int newValue;
        do {
            oldValue = atomicCount.get();  // 获取当前内存值
            newValue = oldValue + 1;       // 计算新值
        } while (!atomicCount.compareAndSet(oldValue, newValue)); // 尝试更改
    }
}

`AtomicInteger`的进阶用法

除了基本的compareAndSet方法外，AtomicInteger还提供了getAndIncrement、getAndDecrement、getAndAdd等实用方法，这些方法都是基于CAS实现的。

public class AtomicIntegerExample {
    private static final AtomicInteger atomicInt = new AtomicInteger(0);

    public static void main(String[] args) {
        System.out.println(atomicInt.getAndIncrement()); // 输出0，然后原子地递增
        System.out.println(atomicInt.get()); // 输出1
        System.out.println(atomicInt.addAndGet(5)); // 原子地增加5，输出6
    }
}

三、CAS的问题与挑战

尽管CAS非常高效，但在某些场景下也面临一些问题和挑战。

1. ABA问题

ABA问题是指在CAS操作期间，内存值发生了A->B->A的变化，但是CAS检测不到这种中间变化。一种典型的解决方案是通过版本号的方式，每次变量更新的同时也更改版本号。

2. 循环时间长开销大

如果并发激烈，导致CAS失败后需要不断重试，这就可能造成较大的CPU开销。为了减少因重试导致的CPU开销，可以引入退避策略（Backoff），即在连续失败后，通过短暂的休眠或者其他操作，减少CPU的无效消耗。

3. 只能保证一个共享变量的原子操作

对于多个共享变量的原子性操作，CAS无能为力。不过，可以通过AtomicReference搭配自定义类的方式实现多变量的原子性操作。

4.锁分离技术的应用

锁分离是一种提高并发度的技术，例如，在实现一个并发队列时，可以为头部和尾部分别使用不同的锁，这样在并发访问时，入队和出队操作就不会相互阻塞。

四、CAS的优化

针对CAS面临的挑战，业界也提出了一些优化策略。

1. 使用带版本号的原子类

Java并未直接提供，但可以通过AtomicStampedReference解决ABA问题，其中“Stamped”即为版本号标记。

public class ABAExample {
    private static AtomicStampedReference<Integer> atomicStampedRef = new AtomicStampedReference<>(0, 0);

    public static void main(String[] args) {
        int stamp = atomicStampedRef.getStamp(); // 获取当前标记
        Integer reference = atomicStampedRef.getReference(); // 获取当前引用

        atomicStampedRef.compareAndSet(reference, reference + 10, stamp, stamp + 1);
    }
}

2. 减少CAS重试

通过算法或者数据结构上的优化来降低并发操作直接的竞争，如无锁算法、协程等。

3. 锁分离

对于高度竞争的环境，可以考虑将大锁（对整个数据结构加锁）细分为多个小锁，将并发操作分布在不同的锁上，提高并行度。

4.无锁数据结构

无锁数据结构，如无锁队列（Michael & Scott算法实现的无锁队列），通过CAS操作来保证数据结构的一致性，而不是使用传统的锁机制。

五、结论

CAS是并发编程中的一种关键性能优化手段，通过硬件层面的支持实现了高效的无锁并发控制。然而，并非所有场景都适合使用CAS，正确评估其适用场景以及权衡在激烈竞争下的性能退化是并发程序设计时不容忽视的因素。此外，解决CAS带来的ABA问题、优化循环竞争的开销以及保证跨多变量的原子性操作，这些都需要工程师根据实际应用场景灵活运用和创新。