概念
compare and swap，解决多线程并行情况下使用锁造成性能损耗的一种机制，CAS操作包含三个操作数——内存位置(V)、预期原值(A)和新值(B)。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。无论哪种情况，它都会在CAS指令之前返回该位置的值。CAS有效地说明了“我认为位置V应该包含值A;如果包含该值，则将B放到这个位置;否则，不要更改该位置，只告诉我这个位置现在的值即可。
简单点来说就是修改之前先做一下对比，校验数据是否被其他线程修改过，如果修改过了，那么将内存中新的值取出在与内存中的进行对比，直到相等，然后再做修改。
假如我们要对变量：num做累加操作，num初始值=0。1.cpu前往内存取出num;2.判断内存中的num是否被修改;3.做+1操作;4.将修改后的值写入内存中;
这时候可能会有疑问了，判断、自加、写回内存难道不会发生线程安全问题吗?既然cas能成为并发编程中安全问题的解决这，那么这个问题肯定是不会发生的，为什么呢?因为判断、自加、写回内存这是一个由硬件保证的原子操作，硬件是如何保证原子性的，请先看下面这个例子
需求：
使用三个线程分别对某个成员变量累加10W，打印累加结果。
我们使用两种方法完成此需求。1.正常累加(既不加锁，也不使用原子类)。
1.使用synchronized。
2.使用原子类(Atomic)。
实现
1.正常累加(既不加锁，也不使用原子类)。
这种方式没有什么说的，直接上代码
- package com.ymy.test;
- public class CASTest {
- private static long count = 0;
- /**
- * 累加10w
- */
- private static void add(){
- for (int i = 0; i< 100000; ++i){
- count+=1;
- }
- }
- public static void main(String[] args) throws InterruptedException {
- //开启三个线程 t1 t2 t3
- Thread t1 = new Thread(() ->{
- add();
- });
- Thread t2 = new Thread(() ->{
- add();
- });
- Thread t3 = new Thread(() ->{
- add();
- });
- long starTime = System.currentTimeMillis();
- //启动三个线程
- t1.start();
- t2.start();
- t3.start();
- //让线程同步
- t1.join();
- t2.join();
- t3.join();
- long endTime = System.currentTimeMillis();
- System.out.println("累加完成，count："+count);
- System.out.println("耗时："+(endTime - starTime)+" ms");
- }
- }
执行结果
很明显，三个线程累加，由于cpu缓存的存在，导致结果远远小于30w，这个也是我们预期到的，所以才会出现后面两种解决方案。
2.使用synchronized
使用synchronized时需要注意，需求要求我们三个线程分别累加10W，所以synchronized锁定的内容就非常重要了，要么直接锁定类，要么三个线程使用同一把锁，关于synchronized的介绍以及锁定内容请参考：java并发编程之synchronized
第一种，直接锁定类，我这里采用锁定静态方法。
我们来改动一下代码，将add方法加上synchronized关键字即可，由于add方法已经时静态方法了，所以现在锁定的时整个CASTest类。
- /**
- * 累加10w
- */
- private static synchronized void add(){
- for (int i = 0; i< 100000; ++i){
- count+=1;
- }
- }
运行结果第一次：
第二次：
第三次：
这里就有意思了，加了锁的运行时间居然比不加锁的运行时间还少?是不是觉得有点不可思议了?其实这个也不难理解，这里就要牵扯到cpu缓存以及缓存与内存的回写机制了，感兴趣的小伙伴可以自行百度，今天的重点不在这里。
第二种：三个线程使用同一把锁
改造代码，去掉add方法的synchronized关键字，将synchronized写在add方法内，新建一把钥匙(成员变量：lock)，让三个累加都累加操作使用这把钥匙，代码如下：
- package com.ymy.test;
- public class CASTest {
- private static long count = 0;
- private static final String lock = "lock";
- /**
- * 累加10w
- */
- private static void add() {
- synchronized(lock){
- for (int i = 0; i < 100000; ++i) {
- count += 1;
- }
- }
- }
- public static void main(String[] args) throws InterruptedException {
- //开启三个线程 t1 t2 t3
- Thread t1 = new Thread(() -> {
- add();
- });
- Thread t2 = new Thread(() -> {
- add();
- });
- Thread t3 = new Thread(() -> {
- add();
- });
- long starTime = System.currentTimeMillis();
- //启动三个线程
- t1.start();
- t2.start();
- t3.start();
- //让线程同步
- t1.join();
- t2.join();
- t3.join();
- long endTime = System.currentTimeMillis();
- System.out.println("累加完成，count：" + count);
- System.out.println("耗时：" + (endTime - starTime) + " ms");
- }
- }
结果如下：
这两种加锁方式都能保证线程的安全，但是这里你需要注意一点，如果是在方法上加synchronized而不加static关键字的话，必须要保证多个线程共用这一个对象，否者加锁无效。
原子类
原子类工具有很多，我们举例的累加操作只用到其中的一种，我们一起看看java提供的原子工具有哪些：
工具类还是很丰富的，我们结合需求来讲解一下其中的一种，我们使用：AtomicLong。
AtomicLong提供了两个构造函数：
value：原子操作的初始值，调用无参构造value=0;调用有参构造value=指定值
其中value还是被volatile 关键字修饰，volatile可以保证变量的可见性，什么叫可见性?可见性有一条很重要的规则：Happens-Before 规则，意思：前面一个操作的结果对后续操作是可见的，线程1对变量A的修改其他线程立马可以看到，具体请自行百度。
我们接着来看累加的需求，AtomicLong提供了一个incrementAndGet()，源码如下：
- /**
- * Atomically increments by one the current value.
- *
- * @return the updated value
- */
- public final long incrementAndGet() {
- return unsafe.getAndAddLong(this, valueOffset, 1L) + 1L;
- }
Atomically increments by one the current value ：原子的增加一个当前值。好了，我们现在试着将互斥锁修改成原子类工具，改造代码：
1.实例化一个Long类型的原子类工具;
2.再for循环中使用incrementAndGet()方法进行累加操作。
改造后的代码：
- package com.ymy.test;
- import java.util.concurrent.atomic.AtomicLong;
- public class CASTest {
- // private static long count = 0;
- //
- // private static final String lock = "lock";
- private static AtomicLong atomicLong = new AtomicLong();
- /**
- * 累加10w
- */
- private static void add() {
- for (int i = 0; i < 100000; ++i) {
- atomicLong.incrementAndGet();
- }
- }
- public static void main(String[] args) throws InterruptedException {
- //开启三个线程 t1 t2 t3
- Thread t1 = new Thread(() -> {
- add();
- });
- Thread t2 = new Thread(() -> {
- add();
- });
- Thread t3 = new Thread(() -> {
- add();
- });
- long starTime = System.currentTimeMillis();
- //启动三个线程
- t1.start();
- t2.start();
- t3.start();
- //让线程同步
- t1.join();
- t2.join();
- t3.join();
- long endTime = System.currentTimeMillis();
- //System.out.println("累加完成，count：" + count);
- System.out.println("累加完成，count：" + atomicLong);
- System.out.println("耗时：" + (endTime - starTime) + " ms");
- }
- }
结果：
可以得到累加的结果也是：30w，但时间却比互斥锁要久，这是为什么呢?我们一起来解剖一下源码。
AtomicLong incrementAndGet()源码解析
- /**
- * Atomically increments by one the current value.
- *
- * @return the updated value
- */
- public final long incrementAndGet() {
- return unsafe.getAndAddLong(this, valueOffset, 1L) + 1L;
- }
- public final long getAndAddLong(Object var1, long var2, long var4) {
- long var6;
- do {
- var6 = this.getLongVolatile(var1, var2);
- } while(!this.compareAndSwapLong(var1, var2, var6, var6 + var4));
- return var6;
- }
我们来看看getAndAddLong方法，发现内部使用了一个 do while 循环，我们看看循环的条件是什么
- public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
这是循环条件的源码，不知道你们发现没有一个关键字：native，表示java代码已经走完了，这里需要调用C/C++代码，这里调用的时C++代码，在这里就要解释一下为什么原子类的比较和赋值是线程安全的，那是因为c++代码中是有加锁的，不知道你们是否了解过内存与cpu的消息总线制，c++就是再消息总线中加了lock，保证了互斥性，所以对比和赋值是一个原子操作，线程安全的。
Unsafe，这个类可以为原子工具类提供硬件级别的原子性，虽然我们java中使用的这些原子工具类虽然都是无锁的，但是我们无需考虑他的多线程安全问题。
为什么原子类比互斥锁的效率低?
好了，现在来思考一下为什么原子工具类的效率会比互斥锁低?明明没有加锁，反而比加了锁慢，这是不是有点不合常理?其实这很符合常理，我们一起来分析一波，CAS(Compare and Swap)重在比较，我们看源码的时候发现有一个 do while循环，这个循环的作用是什么呢?
1.判断期望值是否和内存中的值一致;
2.如果不一致，获取内存中最新的值(var6)，此时期望值就等于了var6，使用改期望值继续与内存中的值做对比，直到发现期望值和内存中的值一致，+1之后返回结果。
这里有一个问题不知道你们发现没有，就是这个循环问题，1.我们假设线程1最先访问内存中的num值=0;加载到cpu中;2.还没有做累加操作，cpu执行了线程切换操作;3.线程2得到了使用权，线程2也去内存中加载num=0，累加之后将结果返回到了内存中;4.线程切回线程1，接着上面的操作，要和内存中的num进行对比，期望值=0，内存num=1，法向对比不上，从新获取内存中的num=1加载到线程1所在的cpu中;5.此时线程又切换了，这次切换了线程3;6.线程3从内存中加载num=1到线程3所在的cpu中，之后拿着期望值=1与内存中的num=1做对比，发现值并没有被修改，此时，累加结果之后写回内存;7.线程1拿到使用权;8.线程1期望值=1与内存num=2做对比，发现又不相同，此时又需要将内存中的新num=3加载到线程1所在的cpu中，然后拿着期望值=2与内存num=2做对比，发现相同，累加将结果写回内存。
这是再多线程下的一种情况，我们发现线程1做了两次对比，而真正的程序循环对比的次数肯定会比我们分析的多，互斥锁三个线程累加10w，只需要累加30万次即可，而原子类工具需要累加30万次并且循环很多次，可能几千次，也可能几十万次，所以再内存中累加操作互斥锁会比原子类效率高，因为内存的执行效率高，会导致一个对比执行很多循环，我们称这个循环叫：自旋。
是不是所有情况下都是互斥锁要快呢?肯定不是的，如果操作的数据再磁盘中，或者操作数据量太多时，原子类就会比互斥锁的性能高很多，这很好理解，就像内存中单线程比多线程效率会更高(一般情况)。
CAS的ABA问题
ABA是什么?我们来举个例子：变量a初始值=0，被线程1获取a=0，切换到线程2，获取a=0，并且将a修改为1写回内存，切换到线程3，再内存中获取数据a=1，将数据修改为0然后写回内存，切换到线程1，这时候线程1发现内存中的值还是0，线程1认为内存中a没有被修改，这时候线程1将a的值修改为1，写回内存。
我们来分析一下这波操作会不会有风险，从表面上看，好像没什么问题，累加或者值修改的时候问题不大，觉得这个ABA没有什么风险，如果你这样认为，那就大错特错了，我举个例子，用户A用网上银行给用户B转钱，同时用户C也在给用户A转钱，我们假设用户A账户余额100元，用户A要给用户B转100元，用户C要给用户A转100元，用户A转给用户B、用户C转给用户A同时发生，但由于用户A的网络不好，用户A点了一下之后没有反应，接着又点了一下，这时候就会发送两条用户A给用户B转100元的请求。
我们假设线程1：用户A第一次转用户B100元
线程2：用户A第二次转用户B100元
线程3：用户C转用户A100元。
线程1执行的时候获取用户A的余额=100元，此时切换到了线程2，也获取到了用户A的余额=100元，线程2做了扣钱操作(update money-100 where money=100)，100是我们刚查出来的，扣完之后余额应该变成了0元，切换到线程3，用户C转给用户A100元，此时用户A的账户又变成了100元，切换到线程1，执行扣钱操作(update money-100 where money=100)，本来是应该扣钱失败的，由于用户C给用户A转了100元，导致用户A的余额又变成了100元，所以线程1也扣钱成功了。
这是不是很恐怖?所以在开发的时候，ABA问题是否需要注意，还请分析好应用场景，像之前说的这个ABA问题，数据库层面我们可以加版本号(版本号累加)就能解决，程序中原子类也给我们提供了解决方案：AtomicStampedReference，感兴趣的小伙伴可以研究一下。其实思路和版本号类似，比较的时候不仅需要比较期望值，还要对比版本号，都相同的情况下才会做修改。
