并发编程----8、CAS与AQS

目录

 

一、并发编程之CAS

1.1、什么是CAS

1.3、CAS底层原理

1.4、CAS原理分析

1.5、CAS应用场景

二、并发编程之AQS

2.1、概念

2.2、基本思想

2.3、CLH同步队列

三、AQS源码分析

---

一、并发编程之CAS

在介绍CAS的时候先说下悲观锁和乐观锁，要不面提到这2个概念，大家会觉得陌生。

悲观锁：写多，读少。所以悲观

乐观锁：读多，写少，有版本控制。

这一章偏理论，因为CAS主要就是一个算法。

1.1、什么是CAS

CAS （compareAndSwap 有的也叫compareAndSet），中文叫比较交换，一种无锁原子算法（乐观锁）。过程是这样：它包含 3 个参数 CAS（V，E，N），V表示要更新变量的值，E表示预期值，N表示新值。仅当 V值等于E值时，才会将V的值设为N，如果V值和E值不同，则说明已经有其他线程做两个更新，则当前线程则什么都不做。最后，CAS 返回当前V的真实值。CAS 操作时抱着乐观的态度进行的，它总是认为自己可以成功完成操作。，其作用是让CPU先进行比较两个值是否相等，然后原子地更新某个位置的值，其实现方式是基于硬件平台的汇编指令，在intel的CPU中，使用的是cmpxchg指令（当你汇编自己的代码的时候会看到好多这个命令，说明很多同步，锁 都是利用CAS实现的哦），就是说CAS是靠硬件实现的，从而在硬件层面提升效率。

当多个线程同时使用CAS 操作一个变量时，只有一个会胜出，并成功更新，其余均会失败。失败的线程不会挂起，仅是被告知失败，并且允许再次尝试，当然也允许实现的线程放弃操作。基于这样的原理，CAS 操作即使没有锁，也可以阻止其他线程对当前线程的干扰。

与锁相比，使用CAS会使程序看起来更加复杂一些，但由于其非阻塞的，它对死锁问题天生免疫，并且，线程间的相互影响也非常小。更为重要的是，使用无锁的方式完全没有锁竞争带来的系统开销，也没有线程间频繁调度带来的开销，因此，他要比基于锁的方式拥有更优越的性能。

简单的说，CAS 需要你额外给出一个期望值，也就是你认为这个变量现在应该是什么样子的。如果变量不是你想象的那样，哪说明它已经被别人修改过了。你就需要重新读取，再次尝试修改就好了。

 

1.2、CAS作用和优缺点

CAS的实现稍微复杂，因为多了一个期望值，但是CAS无锁，不存在阻塞提高了效率，主要表现在CPU的吞吐量

CAS的缺点：

1）循环时间长

如果CAS一直不成功呢？这种情况绝对有可能发生，如果不断自旋但是CAS长时间地不成功，则会给CPU带来非常大的开销。在JUC中有些地方就限制了CAS自旋的次数，例如BlockingQueue的SynchronousQueue。

2）只能保证一个共性变量原子操作

看了CAS的实现就知道这只能针对一个共享变量，如果是多个共享变量就只能使用锁了，当然如果你有办法把多个变量整成一个变量，利用CAS也不错。例如读写锁中state的高低位，利用二进制位来表示不同的变量。

3）ABA问题

CAS需要检查操作值有没有发生改变，如果没有发生改变则更新。但是存在这样一种情况：如果一个值原来是A，变成了B，然后又变成了A，那么在CAS检查的时候会发现没有改变，但是实质上它已经发生了改变，这就是所谓的ABA问题。对于ABA问题其解决方案是加上版本号，即在每个变量都加上一个版本号，每次改变时加1，即A —> B —> A，变成1A —> 2B —> 3A。

改进方法：

类：AtomicStampedReference<V> 

每次改进都会带一个版本号

1.3、CAS底层原理

CAS的产生归功于硬件指令集的发展，实际上，我们可以使用同步将这两个操作变成原子的，但是这么做就没有意义了。所以我们只能靠硬件来完成，硬件保证一个从语义上看起来需要多次操作的行为只通过一条处理器指令就能完成。这类指令常用的有：

1. 测试并设置（Tetst-and-Set）

2. 获取并增加（Fetch-and-Increment）

3. 交换（Swap）

4. 比较并交换（Compare-and-Swap CAS）

5. 加载链接/条件存储（Load-Linked/Store-Conditional）

这个不记住也没关系，看一眼就行了。

CPU如何实现原子指令呢？ 主要有2种方式

1、通过总线锁定来保证原子性

总线锁定其实就是处理器使用了总线锁，所谓总线锁就是使用处理器提供的一个 LOCK# 信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住，那么该处理器可以独占共享内存。但是该方法成本太大。因此有了下面的方式。

2、通过缓存锁定来保证原子性 就是cache line 无效

所谓 缓存锁定是指内存区域如果被缓存在处理器的缓存行中，并且在Lock 操作期间被锁定，那么当他执行锁操作写回到内存时，处理器不在总线上输出 LOCK# 信号，而是修改内部的内存地址，并允许他的缓存一致性机制来保证操作的原子性，因为缓存一致性机制会阻止同时修改两个以上处理器缓存的内存区域数据（这里和 volatile 的可见性原理相同，cache line），当其他处理器回写已被锁定cache line（缓存行）的数据时，会使cache line置为无效。

注意：有两种情况下处理器不会使用缓存锁定。看下就行了。不用刻意记住

1. 当操作的数据不能被缓存在处理器内部，或操作的数据跨多个缓存行时，则处理器会调用总线锁定。

2. 有些处理器不支持缓存锁定，对于 Intel 486 和 Pentium 处理器，就是锁定的内存区域在处理器的缓存行也会调用总线锁定。

1.4、CAS原理分析

AtomicInteger就是利用CAS实现的，所以我们这次以AtomicInteger为例，来分析下它的源码。

先写个代码示例：我们用2种方式实现多线程自增，效果一样，但是原理不一样。

public class CAS1 {
    private static volatile int m=0;
    private static AtomicInteger atomic = new AtomicInteger(0);
    public static void increase1(){
        m++;
    }
    public static void increase2(){
        atomic.incrementAndGet();
    }

    public static void main(String[] args) throws InterruptedException {
        Thread[] t = new Thread[5];
        for(int i=0;i<5;i++){
            t[i] = new Thread(()->{
                CAS1.increase1();
            });
            t[i].start();
            t[i].join();
        }
        System.out.println(m);

        Thread[] t2 = new Thread[5];
        for(int i=0;i<5;i++){
            t2[i] = new Thread(()->{
                CAS1.increase2();
            });
            t2[i].start();
            t2[i].join();
        }
        System.out.println("atomic: "+atomic);
    }
}

 反编译后： javap -c CAS1 大家看到increase1 和increase2 的汇编语句不一样。

我们进入AtomicInteger 源码看看具体干了什么。unsafe是不安全的，后门类，调用cpu指令

 

继续看下incrementAndGet方法的实现，发现调用的是Unsafe的getAndAddInt方法

 

如果我们将10修改为12，则var1就是10，var2就是10，var4是12。如果var1和var2的值一致，则可以修改，则修改成var4。如果不相等，证明被别的线程修改了，则不能修改。

再次进入compareAndSwapInt 会发现这个是个本地方法。在这个Unsafe类中会发现有个调用jvm方法的地方。如果想看jvm的源码，需要下载一个jvm的源码。可以在github去下载。网上资源也很多，不想下载的跟着我着看一眼就可以了。jvm实现都是C++，如果没学过看着也费劲。

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

 

我们将jvm的源码对应起来看下：

实现交换的本地方法如下图。就是这就2行代码，为啥原子性大家明白了吧。cmpxchg这个是一条指令，没办法分隔。

 

整体的调用链是：

incrementAndGet()->unsafe->unsafe.cpp->汇编cmpxchg->二进制

Unsafe是CAS的核心类，Java无法直接访问底层操作系统，而是通过本地（native）方法来访问。不过尽管如此，JVM还是开了一个后门：Unsafe，它提供了硬件级别的原子操作。

 

CAS可以保证一次的读-改-写操作是原子操作，在单处理器上该操作容易实现，但是在多处理器上实现就有点儿复杂了。

缓存加锁：其实针对于上面那种情况我们只需要保证在同一时刻对某个内存地址的操作是原子性的即可。当CPU1修改缓存行中的i时使用缓存锁定，那么CPU2就的缓存行就不能同时缓存i了。

1.5、CAS应用场景

1、应用于简单的数据计算

2、适合线程冲突少的场景

 

CAS的知识差不多就介绍完了，大家看了这些足够了。

二、并发编程之AQS

2.1、概念

AbstractQueuedSynchronizer的缩写是一个同步发射器，用来构建锁。在锁级别上面比CAS高，比Sychronized低。在java.util.concurrent（JUC）包下。

重入锁ReentrantLock，读写锁，信号量 等都是利用AQS来实现的 这个我们在后面锁章节在着重介绍。

从使用层面来说，AQS的功能分为两种：独占和共享

• 独占锁，每次只能有一个线程持有锁，比如ReentrantLock就是以独占方式实现的互斥锁
• 共享锁，允许多个线程同时获取锁，并发访问共享资源，比如ReentrantReadWriteLock （读写锁）

 

2.2、基本思想

通过内置的FIFO同步队列来完成线程争夺资源的管理工作。属于公平的

2.3、CLH同步队列

CLH同步队列也是AQS的实现方式。其主要从两方面进行了改造：把每个线程都看作一个节点，节点的结构与节点等待机制。在结构上引入了头结点和尾节点，他们分别指向队列的头和尾，尝试获取锁、入队列、释放锁等实现都与头尾节点相关，并且每个节点都引入前驱节点和后后续节点的引用；在等待机制上由原来的自旋改成阻塞唤醒。

 

如图所示：每个线程就是一个节点，state表示竞争资源时的同步状态，如果state=0表示当前没有线程占用，如果state>=1表示有线程占用，则其他线程阻塞。

CLH队列在等待的时候会自旋，可以防止线程从用户线程变成内核线程，用户线程变成内核线程非常耗时。

 

AQS的CLH队列相比原始的CLH队列锁，它采用了一种变形操作，将自旋机制改为阻塞机制。当前线程将首先检测是否为头结点且尝试获取锁，如果当前节点为头结点并成功获取锁则直接返回，当前线程不进入阻塞，否则将当前线程阻塞：当前线程如果获取同步状态失败时，AQS则会将当前线程已经等待状态等信息构造成一个节点（Node）并将其加入到CLH同步队列，同时会阻塞当前线程，当同步状态释放时，会把首节点唤醒（公平锁），使其再次尝试获取同步状态。

 

CLH队列的节点都有一个状态位，该状态位与线程状态密切相关：

CANCELLED =  1：因为超时或者中断，节点会被设置为取消状态，被取消的节点时不会参与到竞争中的，他会一直保持取消状态不会转变为其他状态；退出队列；

SIGNAL    = -1：其后继节点已经被阻塞了，到时需要进行唤醒操作；

CONDITION = -2：表示这个结点在条件队列中，因为等待某个条件而被唤醒；（这个可以让指定的线程醒来）

PROPAGATE=-3 ： 共享模式，头结点的状态

 

三、AQS源码分析

 

首先问大家一个问题：在java中如何实现同步？

方法很多：wait/notify 、 synchronized、 ReentrantLock、 ConutDownLatch、 CyclieBarries 、Semaphore 这些都是java提供的可以同步的工具。

因为AQS的加锁和解锁过程，源码也是一堆东西。所以在后续章节专门开一节来讲。欢迎大家订阅并发系列。