java乐观锁 | CAS机制原理

一、乐观锁与悲观锁

---

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

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

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

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

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

二、CAS概述

---

2.1 原子操作简介

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

2.2 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());
    }
}

2.3 CAS优势

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

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

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

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

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

2.4 CAS的应用

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

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

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

三、CAS面对的问题

---

3.1 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();
    }
}

3.2 自旋次数的权衡

  CAS操作在进行比较和交换时，需要在循环中进行自旋，直到成功为止。自旋次数的多少会直接影响系统的性能和资源消耗。

  如果自旋次数过少，可能会导致CAS操作频繁失败，增加了系统开销；如果自旋次数过多，可能会浪费系统资源。

  在实际应用中，需要根据具体情况权衡自旋次数，以达到性能和资源消耗的平衡。

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

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

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

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

2. 原子类：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();
        }
    }
}