CAS、AQS详谈

最新推荐文章于 2025-01-09 15:32:20 发布
转载 最新推荐文章于 2025-01-09 15:32:20 发布 · 139 阅读 · 0
文章标签：

#CAS #AQS

作者https://blog.youkuaiyun.com/u010862794/article/details/72892300

CAS(Compare And Swap)

什么是CAS

CAS(Compare And Swap)，即比较并交换。是解决多线程并行情况下使用锁造成性能损耗的一种机制，CAS操作包含三个操作数——内存位置（V）、预期原值（A）和新值(B)。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。无论哪种情况，它都会在CAS指令之前返回该位置的值。CAS有效地说明了“我认为位置V应该包含值A；如果包含该值，则将B放到这个位置；否则，不要更改该位置，只告诉我这个位置现在的值即可。

在JAVA中，sun.misc.Unsafe 类提供了硬件级别的原子操作来实现这个CAS。 java.util.concurrent 包下的大量类都使用了这个 Unsafe.java 类的CAS操作。至于 Unsafe.java 的具体实现这里就不讨论了。

CAS典型应用

java.util.concurrent.atomic 包下的类大多是使用CAS操作来实现的(eg. AtomicInteger.java,AtomicBoolean,AtomicLong)。下面以 AtomicInteger.java 的部分实现来大致讲解下这些原子类的实现。

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();

    private volatile int value;// 初始int大小
    // 省略了部分代码...

    // 带参数构造函数，可设置初始int大小
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }
    // 不带参数构造函数,初始int大小为0
    public AtomicInteger() {
    }

    // 获取当前值
    public final int get() {
        return value;
    }

    // 设置值为 newValue
    public final void set(int newValue) {
        value = newValue;
    }

    //返回旧值，并设置新值为　newValue
    public final int getAndSet(int newValue) {
        /**
        * 这里使用for循环不断通过CAS操作来设置新值
        * CAS实现和加锁实现的关系有点类似乐观锁和悲观锁的关系
        * */
        for (;;) {
            int current = get();
            if (compareAndSet(current, newValue))
                return current;
        }
    }

    // 原子的设置新值为update, expect为期望的当前的值
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    // 获取当前值current，并设置新值为current+1
    public final int getAndIncrement() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return current;
        }
    }

    // 此处省略部分代码，余下的代码大致实现原理都是类似的
}

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58

一般来说在竞争不是特别激烈的时候，使用该包下的原子操作性能比使用 synchronized 关键字的方式高效的多(查看getAndSet()，可知如果资源竞争十分激烈的话，这个for循环可能换持续很久都不能成功跳出。不过这种情况可能需要考虑降低资源竞争才是)。
在较多的场景我们都可能会使用到这些原子类操作。一个典型应用就是计数了，在多线程的情况下需要考虑线程安全问题。通常第一映像可能就是:

public class Counter {
    private int count;
    public Counter(){}
    public int getCount(){
        return count;
    }
    public void increase(){
        count++;
    }
}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

上面这个类在多线程环境下会有线程安全问题，要解决这个问题最简单的方式可能就是通过加锁的方式,调整如下:

public class Counter {
    private int count;
    public Counter(){}
    public synchronized int getCount(){
        return count;
    }
    public synchronized void increase(){
        count++;
    }
}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

这类似于悲观锁的实现，我需要获取这个资源，那么我就给他加锁，别的线程都无法访问该资源，直到我操作完后释放对该资源的锁。我们知道，悲观锁的效率是不如乐观锁的，上面说了Atomic下的原子类的实现是类似乐观锁的，效率会比使用 synchronized 关系字高，推荐使用这种方式，实现如下:

public class Counter {
    private AtomicInteger count = new AtomicInteger();
    public Counter(){}
    public int getCount(){
        return count.get();
    }
    public void increase(){
        count.getAndIncrement();
    }
}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

AQS(AbstractQueuedSynchronizer)

什么是AQS

AQS(AbstractQueuedSynchronizer)，AQS是JDK下提供的一套用于实现基于FIFO等待队列的阻塞锁和相关的同步器的一个同步框架。这个抽象类被设计为作为一些可用原子int值来表示状态的同步器的基类。如果你有看过类似 CountDownLatch 类的源码实现，会发现其内部有一个继承了 AbstractQueuedSynchronizer 的内部类 Sync 。可见 CountDownLatch 是基于AQS框架来实现的一个同步器.类似的同步器在JUC下还有不少。(eg. Semaphore )

AQS用法

如上所述，AQS管理一个关于状态信息的单一整数，该整数可以表现任何状态。比如， Semaphore 用它来表现剩余的许可数，ReentrantLock 用它来表现拥有它的线程已经请求了多少次锁；FutureTask 用它来表现任务的状态(尚未开始、运行、完成和取消)

 To use this class as the basis of a synchronizer, redefine the
 * following methods, as applicable, by inspecting and/or modifying
 * the synchronization state using {@link #getState}, {@link
 * #setState} and/or {@link #compareAndSetState}:
 *
 * <ul>
 * <li> {@link #tryAcquire}
 * <li> {@link #tryRelease}
 * <li> {@link #tryAcquireShared}
 * <li> {@link #tryReleaseShared}
 * <li> {@link #isHeldExclusively}
 * </ul>
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

如JDK的文档中所说，使用AQS来实现一个同步器需要覆盖实现如下几个方法，并且使用getState,setState,compareAndSetState这几个方法来设置获取状态
1. boolean tryAcquire(int arg)
2. boolean tryRelease(int arg)
3. int tryAcquireShared(int arg)
4. boolean tryReleaseShared(int arg)
5. boolean isHeldExclusively()

以上方法不需要全部实现，根据获取的锁的种类可以选择实现不同的方法，支持独占(排他)获取锁的同步器应该实现tryAcquire、 tryRelease、isHeldExclusively而支持共享获取的同步器应该实现tryAcquireShared、tryReleaseShared、isHeldExclusively。下面以 CountDownLatch 举例说明基于AQS实现同步器, CountDownLatch 用同步状态持有当前计数，countDown方法调用 release从而导致计数器递减；当计数器为0时，解除所有线程的等待；await调用acquire，如果计数器为0，acquire 会立即返回，否则阻塞。通常用于某任务需要等待其他任务都完成后才能继续执行的情景。源码如下:

public class CountDownLatch {
    /**
     * 基于AQS的内部Sync
     * 使用AQS的state来表示计数count.
     */
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

        Sync(int count) {
            // 使用AQS的getState()方法设置状态
            setState(count);
        }

        int getCount() {
            // 使用AQS的getState()方法获取状态
            return getState();
        }

        // 覆盖在共享模式下尝试获取锁
        protected int tryAcquireShared(int acquires) {
            // 这里用状态state是否为0来表示是否成功，为0的时候可以获取到返回1，否则不可以返回-1
            return (getState() == 0) ? 1 : -1;
        }

        // 覆盖在共享模式下尝试释放锁
        protected boolean tryReleaseShared(int releases) {
            // 在for循环中Decrement count直至成功;
            // 当状态值即count为0的时候，返回false表示 signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }

    private final Sync sync;

    // 使用给定计数值构造CountDownLatch
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

    // 让当前线程阻塞直到计数count变为0，或者线程被中断
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    // 阻塞当前线程，除非count变为0或者等待了timeout的时间。当count变为0时，返回true
    public boolean await(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

    // count递减
    public void countDown() {
        sync.releaseShared(1);
    }

    // 获取当前count值
    public long getCount() {
        return sync.getCount();
    }

    public String toString() {
        return super.toString() + "[Count = " + sync.getCount() + "]";
    }
}

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73

本文大致就讲了这些东西，有些地方说的也不是特别好。也有不全的地方，AQS的东西还是有不少的，建议大家自己去看JUC下的各个类的实现，配合《JAVA并发编程实战》这本书，相信是可以看明白的，从而得到更深刻的理解。

最后放个自己的静态页面博客: Vioao’s Blog

大白话聊聊synchronized、CAS底层原理、Lock锁和锁升级原理
qq_36752945的博客
03-11 1187
目录 1、乐观锁和悲观锁的概念 2、synchronized底层的原理 3. CAS的原理 4. 并发包下Lock锁和synchronized对比 5. 锁升级原理 大家好，我是四九城最豪横的小耳朵。 今天咱们来用大白话聊聊synchronized、CAS底层原...
CAS与AQS简单理解
m0_71777195的博客
07-15 2005
所谓的AQS既是compareAndSwap的缩写，翻译过来既是“对比和交换”的意思。那怎么去对比呢，画个小图理解下3个值分别对应的含义新的值需要修改过后的值内存变量的值在内存的值是多少旧的预期值这里相当于内存的值的一个副本，copy过来的如果内存的值等于旧的预期值，那么就把新的值替换为内存中的值，否则什么都不做这里就是自旋锁AtomicInteger就是用到CAS来实现的。//类似上述全局内存共享变量V//CAS操作打印是否修改成功true修改后的值1。...
AQS CAS简单详解（写的比较好）
热门推荐
zcw4237256的博客
11-16 3万+
CAS(Compare And Swap) 什么是CAS CAS(Compare And Swap)，即比较并交换。是解决多线程并行情况下使用锁造成性能损耗的一种机制，CAS操作包含三个操作数——内存位置（V）、预期原值（A）和新值(B)。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。无论哪种情况，它都会在CAS指令之前返回该位置
Cas的功能和应用
qq_61925446的博客
05-06 586
cas比较的原数据和被记录下的数据的大小来判断原数据是否在被记录下来之后发生了改变， 但是如果原数据A被记录下来后，先被改变成了B，然后又被改回了A，此时cas还是认为原数据A没有被改变，会直接执行交换的操作。cas作为while的循环条件，只有当cas返回true时，循环才会结束，线程就获得了锁，否则cas返回false，while循环就一直循环。版本号法：为每个原数据都设置一个版本号，原数据改变一次，版本号就递增，版本号永远不会重复，此时根据版本号来比较数据是否改变，就不会出现ABA问题。
Java中的锁（5）：乐观锁的时间机制---CAS实现原理
区块链之美
08-10 869
乐观锁思想实现原理是一种无锁原理。CAS指令是实现无锁原理的方案之一。 1、CAS是什么？ CAS的全称是Compare And Swap，即比较交换。  其核心思想： CAS(V,E,N);   V表示要更新的变量的内存位置，E表示更新变量的预期原值，N表示更新变量的更新值。 在当前线程中，如果要更新变量预期原值E等于当前内存位置中的值，就把更新该内存位置的值，更新后的值为N。如果不相等...
什么是CAS锁
jakelihua
03-19 2845
在并发编程中，CAS（Compare And Swap）锁是一种乐观锁机制，用于实现多线程之间的同步。CAS操作包括三个步骤：读取内存值、比较内存值与预期值、如果相等则更新内存值。CAS锁可以有效地解决传统锁机制中的性能问题和死锁问题，是并发编程中常用的同步手段之一。
并发编程核心技术揭秘：CAS和AQS详解与应用案例
逆流的小鱼
05-31 457
AbstractQueuedSynchronizer（AQS）是实现依赖于先进先出（FIFO）等待队列的同步器的框架。它为多个同步器提供了一个可重用的基础，如ReentrantLock、Semaphores、CountDownLatch等。AQS使用一个int类型的成员变量表示同步状态（state），并通过内置的FIFO队列来管理线程。同步状态（State）：表示资源的占用情况。节点（Node）：构成等待队列，存储线程信息。内置FIFO队列：管理因获取状态失败而等待的线程。
CAS和AQS
weixin_45615504的博客
11-27 3303
1、CAS是乐观锁，在concurrentHashmap中的putval方法中会用到CAS 非阻塞的实现CAS：CAS指令需要3个操作数，分别是内存地址（在JAVA中理解为变量的内存地址，用V表示），旧的预期值（用A表示），新值（B）。CAS指令执行时，当且仅当V处的值符合旧预期值A时，处理器用B更新A值，否则它就不执行更新，但是无论是否更新了V处的值，都会返回V的旧值，上述的处理过程是一个原子操作。 CAS缺点 ：ABA问题：因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是
Java 面试中常见的 CAS 和 AQS 问题解析
道长的博客
07-11 815
在 Java 面试中，CAS（Compare and Swap，比较并交换）和AQS（AbstractQueuedSynchronizer，抽象队列同步器）是经常被问到的重要知识点。下面为大家整理了一些常见的面试题及详细解析。
线程CAS AQS浅谈
qq_43081106的博客
01-17 451
线程CAS AQS浅谈面试必备，适合快速上手理解。
【Java】CAS底层原理和自旋锁的使用
Your_Boy_Tt的博客
12-13 769
CAS 的全称为 Compare-And-Swap，它是一条 CPU 并发原语。它的功能是判断内存某个位置的值是否为预期值，如果是则更新为新的值，这个过程是原子的。CAS 并发原语体现在 Java 语言中就是 sun.miscUnSafe 类中的各个方法。调用 UnSafe 类中的 CAS 方法，JVM 会帮我们实现 CAS 汇编指令。这是一种完全依赖于硬件功能的指令，通过它实现了原子操作。
加锁CAS的底层原理
qq_40276626的博客
11-02 1355
加锁的底层利用的是CPU的一个原子指令，CompareAndSwap，也就是我们说的CAS。 如何加锁呢？ 拿互斥锁为例，在一块内存中维护一个变量和线程信息，当变量为0的时候，代表当前无锁，当变量为1的时候，代表有锁，并将自己的线程信息写入，代表当前线程占用锁了。 每个想要拿到锁的线程都通过CPU的CompareAndSwap指令来获取锁，对应的指令为cas（addr，0，1），这条指令的意思是地址为adder的内存中存储的变量取值为0的时候，才将变量改为1，表示加锁成功。 1、首先来说，CPU的架构决定了
CAS操作的底层原理（总线锁定机制和缓存锁定机制 ）
xweiran的博客
01-09 1139
先总结一下，CAS是一种硬件级的原子操作，通过总线锁或缓存锁实现原子性，在使用缓存锁的时候缓存一致性协议保证数据一致性。而Java通过native方法调用底层CAS指令，需要考虑ABA问题和性能优化，而cas这种机制保证了在多处理器系统中的原子操作，是实现无锁并发的基础。
初识CAS锁（概述、底层原理、原子引用、自旋锁、缺点）
花&败
09-04 2018
CAS的全称为Compare-And-Swap，直译就是对比交换。是一条CPU的原子指令，其作用是让CPU先进行比较两个值是否相等，然后原子地更新某个位置的值。经过调查发现，其实现方式是基于硬件平台的汇编指令，就是说CAS是靠硬件实现的，JVM只是封装了汇编调用，那些AtomicInteger类便是使用了这些封装后的接口。CAS操作需要输入两个数值，一个旧值(期望操作前的值)和一个新值，在操作期间先比较下在旧值有没有发生变化，如果没有发生变化，才交换成新值，发生了变化则不交换。
深入理解Java并发编程之AQS（包含CAS讲解）
不定期更新Java相关的各种内容
09-24 224
JUC之AQS
锁与CAS详解
向上的"狼"的博客
04-29 501
一. 悲观锁与乐观锁 乐观锁和悲观锁问题，是出现频率比较高的面试题。本文将由浅入深，逐步介绍它们的基本概念、实现方式(含实例)、适用场景，以及可能遇到的面试官追问，希望能够帮助你打动面试官。 乐观锁和悲观锁是两种思想，主要是解决并发场景下的数据争夺的问题。 乐观锁：乐观锁在操作数据时非常乐观，认为别人不会同时修改数据。因此乐观锁不会上锁，只是在执行更新的时候判断一下在此期间别人是否修改了数据：如果别人修改了数据则放弃操作，否则执行操作。 悲观锁：悲观锁在操作数据时比较悲观，认
什么是 CAS 锁
2401_87715873的博客
12-03 1084
CAS锁，全称为Compare-And-Swap锁，是一种基于硬件支持的原子性操作，用于在多线程环境中保证对共享资源的原子性访问。它通过比较内存中的值与预期值是否相等，来决定是否更新内存值。
「JUC并发编程」初识CAS锁（概述、底层原理、原子引用、自旋锁、缺点）
frozenpenguin的博客
08-30 7268
CAS的全称为，直译就是对比交换。是一条CPU的原子指令，其作用是让CPU先进行比较两个值是否相等，然后原子地更新某个位置的值。经过调查发现，其实现方式是基于硬件平台的汇编指令，就是说CAS是靠硬件实现的，JVM只是封装了汇编调用，那些AtomicInteger类便是使用了这些封装后的接口。简单解释：CAS操作需要输入两个数值，一个旧值(期望操作前的值)和一个新值，在操作期间先比较下在旧值有没有发生变化，如果没有发生变化，才交换成新值，发生了变化则不交换。...
CAS的底层原理
疯癫的专栏
03-08 1187
1,什么是CAS?
cas和aqs
最新发布
07-02
### CAS 与 AQS 的区别与实现原理 #### CAS（Compare-And-Swap） CAS 是一种 **无锁并发** 的实现方式，属于乐观锁策略。它通过硬件级别的原子操作来保证线程安全，避免了传统互斥锁带来的性能开销。 - **核心原理**： CAS 操作包含三个参数：目标变量 `V`、预期值 `E` 和新值 `N`。其逻辑是：如果当前变量的值等于预期值，则将其更新为新值；否则不进行任何操作，并返回失败。这一过程是原子性的，依赖 CPU 指令（如 `cmpxchg`）完成[^3]。 - **Java 中的实现**： Java 使用 `sun.misc.Unsafe` 类提供的本地方法实现 CAS 操作，例如 `compareAndSwapInt()`、`compareAndSwapLong()` 等。同时，`volatile` 关键字确保变量在内存中的可见性，从而保证线程能够获取到最新的值[^2]。 - **优点与局限性**： - **优点**：避免了线程阻塞，提高了并发性能。 - **局限性**：存在 ABA 问题（即变量被修改后又恢复原值）、自旋重试可能导致 CPU 资源浪费，以及只能对单个变量进行原子操作等问题。 #### AQS（AbstractQueuedSynchronizer） AQS 是一个用于构建同步器的框架，广泛应用于 `ReentrantLock`、`CountDownLatch`、`Semaphore` 等并发工具类中。 - **核心设计思想**： AQS 基于一个 `state` 变量表示同步状态，采用 CLH 队列（变种）管理等待线程，结合 CAS 实现状态变更的原子性，并使用 `LockSupport` 控制线程的阻塞与唤醒[^1]。 - **内部结构**： - **同步状态（state）**：用于表示资源是否被占用。 - **等待队列（CLH 变体）**：维护等待获取资源的线程节点。 - **资源共享模式**：支持独占（exclusive）和共享（shared）两种模式。 - **资源获取与释放流程**： - **独占模式**：线程尝试通过 CAS 修改 `state`，成功则获得锁；失败则进入等待队列并挂起。 - **共享模式**：多个线程可以同时获取资源，适用于读多写少的场景。 - **ConditionObject**：提供条件变量机制，实现类似 `wait/notify` 的协作控制。 - **公平性与非公平性策略**： AQS 支持公平锁和非公平锁，默认是非公平的。公平锁确保等待时间最长的线程优先获取资源，而非公平锁允许“插队”以提升吞吐量。 #### 区别总结 | 特性 | CAS | AQS | |------|-----|-----| | **定位** | 底层原子操作指令 | 同步器框架 | | **实现层级** | CPU 指令级 | Java 层封装 | | **适用范围** | 单变量原子操作 | 多线程同步控制 | | **线程调度** | 无队列机制，依赖自旋 | 内置 CLH 队列管理等待线程 | | **功能复杂度** | 简单高效 | 功能丰富，支持多种同步语义 | | **典型应用** | AtomicInteger、AtomicReference | ReentrantLock、Semaphore、CountDownLatch | #### 示例代码：基于 AQS 实现的简单可重入锁 ```java import java.util.concurrent.locks.AbstractQueuedSynchronizer; public class SimpleReentrantLock { private final Sync sync = new Sync(); public void lock() { sync.acquire(1); } public void unlock() { sync.release(1); } private static class Sync extends AbstractQueuedSynchronizer { @Override protected boolean tryAcquire(int acquires) { if (compareAndSetState(0, 1)) { setExclusiveOwnerThread(Thread.currentThread()); return true; } else if (getExclusiveOwnerThread() == Thread.currentThread()) { // 可重入逻辑 setState(getState() + 1); return true; } return false; } @Override protected boolean tryRelease(int releases) { int nextc = getState() - releases; if (nextc == 0) { setExclusiveOwnerThread(null); } setState(nextc); return true; } @Override protected boolean isHeldExclusively() { return getState() > 0; } } } ``` ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值