CAS机制原理

引言

CAS（比较并交换）操作是一种原子性操作。原子性是指一个操作要么完全执行成功，要么完全不执行，没有中间状态。在CAS操作中，一个共享变量的比较和交换是作为一个原子操作来执行的，不会出现比较后、插入前，这段是时间有其他线程修改共享变量的值的情况。

乐观锁与悲观锁

乐观锁和悲观锁是对锁的不同分类方式。

• 悲观锁

  • 悲观锁是传统的锁机制，它假设在访问共享资源时会发生冲突，因此每次数据操作都需要加锁，以确保临界区的程序同一时间只有一个线程执行。

• 乐观锁

  • 相反，乐观锁是一种无锁的机制，它乐观地认为对共享资源的访问不会发生冲突。线程可以不断执行，无需加锁或等待。当多个线程发生冲突时，乐观锁通常使用一种称为 CAS（比较并交换） 的技术来保证线程执行的安全性。

  • 由于乐观锁没有锁的存在，因此不存在死锁的情况。乐观锁常用于读多写少的场景，避免频繁加锁对性能的影响。而悲观锁多用于写多读少的场景，避免频繁的失败和重试对性能的影响。

  • 总结来说，乐观锁和悲观锁是对锁的不同看法和应用方式，根据具体的场景选择适合的锁机制可以提高并发性能和线程安全性。

CAS概述

原子操作简介

什么是原子操作？

原子操作(atomic operation)是不需要synchronized"，这是多线程编程的老生常谈了。所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch [1]（切换到另一个线程）。

• CAS（比较并交换）操作是一种原子性操作。原子性是指一个操作要么完全执行成功，要么完全不执行，没有中间状态。在CAS操作中，一个共享变量的比较和交换是作为一个原子操作来执行的，不会出现比较后、插入前，这段是时间有其他线程修改共享变量的值的情况。

CAS操作原理

CAS（Compare and Swap）是一种乐观锁机制，用于解决并发环境下的数据竞争问题。它的基本原理是先比较内存中的值与期望值是否相等，如果相等，则将新值写入内存；否则，重新进行比较。

- CAS操作通常涉及三个操作数：

1. 内存地址(或者称为变量的偏移量)
2. 期望值
3. 新值

如果当前内存地址中的值与期望值相等， 则将新值写入内存， 否则循环尝试或失败

当多个线程同时使用CAS操作一个变量时，只有一个会胜出，并成功更新，其余均会失败，但失败的线程并不会被挂起，仅是被告知失败，并且允许再次尝试，当然也允许失败的线程放弃操作。下面是一个使用CAS操作的示例代码：

import java.util.concurrent.atomic.AtomicInteger;

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

    public static void main(String[] args) {
        System.out.println("初始值：" + counter.get());

        int expectValue = 0;
        int newValue = 10;

        boolean updated = counter.compareAndSet(expectValue, newValue);
        System.out.println("更新结果：" + updated);

        System.out.println("最终值：" + counter.get());
    }
}

CAS的优势

CAS机制相对于传统的锁机制具有一些优势。

• 原子性

  • CAS操作具有原子性，能够在多线程环境下实现高效的数据更新。

• 无锁

  • CAS操作不需要使用锁，避免了线程的阻塞和唤醒，减少了上下文切换的开销，在并发度较高的情况下，能够提供更好的性能。

• 避免死锁

  • 由于CAS操作不需要使用锁，因此避免了传统锁机制中可能发生的死锁和线程饥饿问题。

• 支持并发

  • CAS操作通过乐观锁的方式进行数据更新，不会阻塞其他线程的执行，提高了系统的吞吐量和响应性能。

CAS的应用

1. 在多线程环境下的数据同步

   • 在多线程环境下，CAS操作可以避免多个线程同事修改同一个变量造成的数据不一致问题

2. 在线程安全性保证中的应用

   • 通过使用CAS操作，可以实现非阻塞式的线程安全控制，避免使用传统锁机制带来的线程阻塞和唤醒开销。

3. 在并发容器中的应用

   • 常见的并发容器包括ConcurrentHashMap、ConcurrentLinkedQueue等。这些容器内部使用了CAS操作来实现线程安全性和高效的并发访问。

CAS会产生的问题

ABA问题

• CAS操作无法解决ABA问题，即在操作过程中，变量的值经过多次变化后又恢复为原来的值。这可能导致CAS操作在判断变量值是否发生变化时出现错误。

• 为了解决ABA问题，可以使用版本号或时间戳来辅助CAS操作。通过引入额外的信息，可以在比较和交换过程中判断变量值是否发生了实质性的变化。

下面是一个使用标记位解决ABA问题的示例代码：

import java.util.concurrent.atomic.AtomicStampedReference;

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

    public static void main(String[] args) {
        new Thread(() -> {
            int expectedValue = counter.getReference();
            int newStamped = counter.getStamp() + 1;
            int newValue = expectedValue + 1;
            boolean updated = counter.compareAndSet(expectedValue, newValue, 0, newStamped);
            System.out.println("线程1 更新结果：" + updated);
        }).start();

        new Thread(() -> {
            int expectedValue = counter.getReference();
            int newStamped = counter.getStamp() + 1;
            int newValue = expectedValue + 1;
            boolean updated = counter.compareAndSet(expectedValue, newValue, 0, newStamped);
            System.out.println("线程2 更新结果：" + updated);
        }).start();
    }
}

自旋次数的权衡

CAS操作在进行比较和交换时，需要在循环中进行自旋，直到成功为止。自旋次数的多少会直接影响系统的性能和资源消耗。如果自旋次数过少，可能会导致CAS操作频繁失败，增加了系统开销；如果自旋次数过多，可能会浪费系统资源。在实际应用中，需要根据具体情况权衡自旋次数，以达到性能和资源消耗的平衡。

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

CAS只能保证单个共享变量的原子操作，对于涉及多个共享变量的复合操作，CAS无法提供直接的支持。

但是可以通过一些辅助机制来解决这个问题，下面介绍两种常见的方法：

• 锁机制：可以使用传统的锁机制（如synchronized关键字或ReentrantLock）来保证多个共享变量的原子操作。通过获取锁，将多个操作作为一个临界区，确保这些操作的执行是互斥的，从而实现原子性。

• 原子类：Java提供了一些原子类（如AtomicInteger、AtomicLong、AtomicReference等），它们封装了底层的CAS操作，可以实现多个共享变量的原子操作。这些原子类提供了一些常见的原子操作方法，如compareAndSet、getAndSet等，可以保证多个变量之间的操作是原子的。

实操

背景：假设有一个并发任务，需要对一个共享的计数器进行递增操作。为了保证并发安全性，我们可以使用CAS（比较并交换）机制来实现原子性的计数器递增操作。

下面是一个使用CAS实现计数器递增的示例代码：

import java.util.concurrent.atomic.AtomicInteger;

public class CASCounterExample {
    private static AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) {
        // 创建并发任务的线程数
        int numThreads = 10;

        // 创建并启动多个线程
        for (int i = 0; i < numThreads; i++) {
            new Thread(() -> {
                // 执行计数器递增操作
                int oldValue, newValue;
                do {
                    // 读取当前计数器的值
                    oldValue = counter.get();

                    // 计算递增后的新值
                    newValue = oldValue + 1;

                    // 使用CAS操作进行原子性的递增操作
                } while (!counter.compareAndSet(oldValue, newValue));

                // 输出递增后的值
                System.out.println("递增后的值：" + newValue);
            }).start();
        }
    }
}