cas是如何保证原子性的？？

目录

一、volatile关键字

volatile的特性

1、保证可见性

2、不保证原子性

3、禁止指令重排序

二、AtomicInteger&&CAS&&Unsafe

一、volatile关键字

volatile的特性

1. 可见性
2. 不保证原子性
3. 有序性（禁止指令的重排序）

1、保证可见性

在我们java内存中，有主内存（公共内存）和工作内存（线程内的私有内存）。在我们多线程访问的时候，需要先将主内存（公共内存）中的数据拷贝一份到线程的工作内存（线程私有内存）中，然后改变数据后，再写入到主内存中。但是如果是正常的（不加synchornized或者锁的情况下），那么其中一个线程A访问的时候，在写入主内存的操作的时候对其他线程（比如线程B）是不会显示的，如果在线程A写入之前，线程B已经从主内存中读到了更改之前的数据，那么就会发生线程不安全的情况。

使用volatile 关键字修饰的数据，就会使A线程在更改了数据的时候，将更改的信息立刻通知其他线程，保证了内存的可见性。

那么是不是用volatile修饰多线程访问的数据就可以保证线程安全呢？？？？？

答案是否

2、不保证原子性

public class Volatile1 {

    public volatile static int sum= 0;

    public static void main(String [] args){
        //开启20个线程
        for(int i = 0;i < 20; i++){
            new Thread(new Runnable() {

                @Override
                public void run() {
                    //每个线程中让count的值自增100次
                    for(int j = 0;j < 100;j++){
                        sum++;
                    }
                }
            }).start();
        }
        while (Thread.activeCount()>2){//主线程+回收线程有两个，如果大于两个，说明上面线程还有执行完
            Thread.yield();//一直等待
        }
        System.out.println("sum= " + sum);
    }
    }

运行结果

我们发现正常情况应该是20个线程每个线程执行一百次自增方法，应该最终结果是2000，但是几乎每次结果都小于2000。

 使用volatile修饰的变量，为什么并发自增的时候会出现这样的问题呢？

       这是因为count++这一行代码本身并不是原子性操作，在字节码层面可以拆分成如下指令： 
         getstatic     //读取静态变量（count）
         iconst_1     //定义常量1
         iadd            //count增加1
         putstatic     //把count结果同步到主内存 

虽然每一次执行 getstatic 的时候，获取到的都是主内存的最新变量值，但是进行iadd的时候，由于并不是原子性操作，其他线程在这过程中很可能让count自增了很多次。

这样一来本线程所计算更新的是一个陈旧的count值，自然无法做到线程安全。

那么如何解决上述问题呢？？其中一个解决方法就是用JUC.atomic包中的原子类AtomicInteger

3、禁止指令重排序

可以参考https://blog.csdn.net/qq_24047659/article/details/88031712作者：独家技术

二、AtomicInteger&&CAS&&Unsafe

先看下面代码，我们将int类型的sum改用AtomicInteger类型

import java.util.concurrent.atomic.AtomicInteger;

public class Volatile1 {

    public static AtomicInteger sum= new AtomicInteger(0);

    public static void main(String [] args){
        //开启20个线程
        for(int i = 0;i < 20; i++){
            new Thread(new Runnable() {

                @Override
                public void run() {
                    //每个线程中让count的值自增100次
                    for(int j = 0;j < 100;j++){
                        sum.getAndIncrement();
                    }
                }
            }).start();
        }

        while (Thread.activeCount()>2){//主线程+回收线程有两个，如果大于两个，说明上面线程还有执行完
            Thread.yield();//一直等待
        }
        System.out.println("sum= " + sum);
    }
    }

运行结果：

我们发现每次运行结果都是2000.

查看getAndAddInt源码发现该方法调用了Unsafe类中的getAndAddInt方法

 public final int getAndIncrement() {
        return U.getAndAddInt(this, VALUE, 1);
    }

  @HotSpotIntrinsicCandidate
    public final int getAndAddInt(Object o, long offset, int delta) {
        int v;
        do {
            v = this.getIntVolatile(o, offset);
        } while(!this.weakCompareAndSetInt(o, offset, v, v + delta));

        return v;
    }

我们注意看Unsafe类中的getAndAddInt方法，o参数代表当前对象，这里就是AtomicInteger类型的sum对象，offset是long类型的，代表内存的偏移量，我们通过o和offset两个参数就可以直接到内存中取到该位置上的值。既内存中存储的sum的值。delta参数值一次操作要+的数值，这里我们是自增，既是1。

那么局部变量v我们就可以把它理解为要读到我们工作内存中的数据

do...while.. 循环就是体现了我们的CAS原理：比较并交换。

如果我们读到的v（既预期值）与我们while条件中调用weakCompareAndSetInt中快照获取的内存中的值一致 的话，那么我们就将变更后的值进行写入到主内存中的操作进行下去；如果预期值与实际的值不一致（即已经有其他的线程捷足先登，提前改变了这个值，那么我们再取主内存中最新的值，进行循环的比较与交换操作）。通过这个方式就可以保证操作的原子性。

这里写的比较简单了，具体的以后可以再总结，很晚了，睡觉~