Java-CAS(三)

灰太狼 2023-10-12 10:19 7阅读 0赞

## Java-CAS(三) ##

### 基本概念 ###

CAS的全称为Compare-And-Swap，直译就是对比交换。是一条CPU的原子指令，其作用是让CPU先进行比较两个值是否相等，然后原子地更新某个位置的值，经过调查发现，其实现方式是基于硬件平台的汇编指令，就是说CAS是靠硬件实现的，JVM只是封装了汇编调用，那些AtomicInteger类便是使用了这些封装后的接口。   简单解释：CAS操作需要输入两个数值，一个旧值(期望操作前的值)和一个新值，在操作期间先比较下在旧值有没有发生变化，如果没有发生变化，才交换成新值，发生了变化则不交换。

它是一种用于实现多线程同步的技术。CAS操作涉及比较一个内存位置的值与预期值，如果相等，就将该位置的值更新为新的值。整个操作是原子性的，意味着它可以在没有锁定的情况下进行，并且能够保证线程安全。  
为了更好地理解CAS。假设去购买一本书，但是不知道书店中是否还有库存。你先向书店的工作人员询问是否还有一本特定的书，如果工作人员告诉你还有库存，你会立即购买。这个过程就类似于CAS操作。  
具体来说，这个过程包含以下步骤：

你首先记住了你要购买的书的名字和数量。  
你询问工作人员关于该书的库存情况。  
如果工作人员告诉你库存中确实还有这本书，你立即告诉工作人员购买这本书，并将预期的数量支付给他们。  
如果工作人员告诉你库存中没有这本书，你将不会购买，并继续其他的购物活动。  
在这个比喻中，你是一个线程，书店是共享资源，你购买书的过程类似于CAS操作。你首先检查预期值（库存是否有书），然后进行比较（询问工作人员），最后进行交换（购买书籍）。这种方式避免了锁定整个书店，而是只在需要的时候进行操作，提高了效率并确保了线程安全。

### ABA问题 ###

ABA问题是指在并发编程中，一个共享变量从初始值A经过一系列操作变为值B，然后再回到值A的情况下，CAS操作无法察觉到中间的变化。

这个问题通常发生在使用CAS操作进行原子比较和交换时，由于CAS只关注值的变化，而不考虑变化的顺序，因此可能会导致一些意外的结果。

下面是一个简单的示例来说明ABA问题：

假设有两个线程，线程A和线程B，它们同时从共享变量中读取值。初始情况下，共享变量的值为A。

1.  线程A读取共享变量的值为A。
2.  在线程A读取值后，线程B开始执行并将共享变量的值从A修改为B。
3.  接着，线程B又将共享变量的值从B修改回A。
4.  最后，线程A继续执行CAS操作，比较共享变量的值与之前读取的A值，发现相等，于是进行更新操作。

尽管CAS操作成功地比较了共享变量的值与预期的A值，并进行了更新，但实际上在中间发生了一次值的改变（从A变为B再变回A）。这种情况下，CAS操作无法察觉到中间的变化，从而可能导致意外的结果。

### Java中相关类 ###

在Java中，java.util.concurrent.atomic\`包提供的一组类来实现的。下面是与CAS相关的主要类：

1.  `AtomicBoolean`：提供了对`boolean`类型的原子操作。它包含`get()`、`set()`和`compareAndSet()`等方法，用于获取、设置和比较设置操作。
2.  `AtomicInteger`：提供了对`int`类型的原子操作。它包含了一系列的原子操作方法，如`get()`、`set()`、`incrementAndGet()`、`compareAndSet()`等。
3.  `AtomicLong`：提供了对`long`类型的原子操作。它也包含了一系列的原子操作方法，如`get()`、`set()`、`incrementAndGet()`、`compareAndSet()`等。
4.  `AtomicReference`：提供了对引用类型的原子操作。可以使用它来保证对引用对象的原子读取和写入操作，以及基于引用对象的比较和交换操作。

这些类的主要优点是它们避免了使用锁机制，提供了一种高效的方式来实现线程安全。它们适用于在多线程环境下对变量进行更新和比较的场景。

请注意，虽然CAS操作可以确保线程安全，但在某些情况下可能会出现ABA问题。ABA问题是指当一个值从A变为B，再从B变为A时，CAS操作无法察觉到中间的变化。为了解决这个问题，Java提供了`AtomicStampedReference`类，它可以追踪变量的修改次数，避免了ABA问题的发生。

### AtomicInteger类 ###

`AtomicInteger`是Java中的一个原子类，用于对整型变量进行原子操作。它提供了一系列的原子操作方法，可以保证在多线程环境下对整型变量的操作是原子的。

内部变量：`AtomicInteger`内部通过`volatile`修饰的`value`变量来存储整型的值。`volatile`关键字确保了多线程之间对`value`的可见性。

#### 重要属性 ####

private static final Unsafe unsafe = Unsafe.getUnsafe();
    private volatile int value;

Unsafe 提供了硬件级别的操作，比如说获取某个属性在内存中的位置，比如说修改对象的字段值，即使它是私有的。

`AtomicInteger`使用`unsafe`对象来执行CAS操作。`unsafe`是一个特殊的类，提供了直接访问底层内存的方法。`AtomicInteger`通过调用`unsafe.compareAndSwapInt(Object obj, long offset, int expect, int update)`方法执行CAS操作。

#### 原子操作方法 ####

`AtomicInteger`提供了一系列原子操作方法，包括：

*  `get()`：获取当前的值。
 *  `set(int newValue)`：设置新的值。
 *  `getAndSet(int newValue)`：获取当前的值并设置新的值。
 *  `compareAndSet(int expect, int update)`：比较当前的值与预期值，如果相等则更新为新的值。
 *  `incrementAndGet()`：先增加当前的值，然后返回增加后的值。
 *  `decrementAndGet()`：先减少当前的值，然后返回减少后的值。
 *  `getAndIncrement()`：先返回当前的值，然后增加值。
 *  `getAndDecrement()`：先返回当前的值，然后减少值。
    
        public final boolean compareAndSet(int expect, int update) {
                return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
            }

在类中可以看到以上某些方法实际也是调用unsafe进行操作。

重点方法：  
其中，`compareAndSet(int expect, int update)`是`AtomicInteger`中的一个重点方法。它通过比较当前值与预期值，如果相等则将当前值更新为新的值。这个方法在实现自旋锁和无锁算法时非常有用。

另外，`incrementAndGet()`和`decrementAndGet()`方法分别用于自增和自减操作。它们先对当前值进行增加或减少操作，然后返回操作后的结果，保证了原子性。

#### 小结 ####

`AtomicInteger`是Java中用于对整型变量进行原子操作的原子类。它使用CAS操作来实现原子性，避免了使用锁带来的开销和复杂性

### AQS和CAS的 ###

AQS（AbstractQueuedSynchronizer）和CAS（Compare and Swap）都是Java并发编程中常用的概念和机制，用于实现线程同步和原子操作。

AQS（AbstractQueuedSynchronizer）是一个用于构建锁和同步器的抽象基类，它提供了一种灵活的方式来实现各种同步机制。AQS内部使用一个等待队列（由节点组成）来管理等待获取锁或资源的线程，并通过CAS操作来实现线程的安排和唤醒。AQS可以用来实现独占锁（如ReentrantLock）和共享锁（如Semaphore、CountDownLatch等），以及其他自定义的同步器。

CAS（Compare and Swap）是一种乐观锁定机制，用于实现原子操作。CAS操作包含三个操作数：内存位置、预期值和新值。CAS操作会比较内存位置的值与预期值，如果相等，则将内存位置的值更新为新值，否则不做任何操作。CAS操作是原子的，可以在没有锁的情况下进行，避免了传统锁机制带来的开销和竞争。CAS常用于实现无锁算法、并发集合类以及一些原子类（如AtomicInteger、AtomicLong等）。

AQS和CAS在Java并发编程中通常一起使用，实现线程同步和原子操作的需求。AQS提供了底层的等待队列管理和线程调度机制，而CAS提供了一种安全且高效的原子操作方式。通过结合使用AQS和CAS，可以实现高性能的线程同步和原子操作，避免了传统锁机制的开销和竞争。