volatile不保证原子性及其解决办法

1.volatile不保证原子性

既然它可以保证修改的值立即能更新到主存，其他线程也会捕捉到被修改后的值，那么为什么不能保证原子性呢？
首先需要了解的是，Java中只有对基本类型变量的赋值和读取是原子操作，如i = 1的赋值操作，但是像j = i或者i++这样的操作都不是原子操作，因为他们都进行了多次原子操作，比如先读取i的值，再将i的值赋值给j，两个原子操作加起来就不是原子操作了。

所以，如果一个变量被volatile修饰了，那么肯定可以保证每次读取这个变量值的时候得到的值是最新的，但是一旦需要对变量进行自增这样的非原子操作，就不会保证这个变量的原子性了。

举个栗子：

一个变量i被volatile修饰，两个线程想对这个变量修改，都对其进行自增操作也就是i++，i++的过程可以分为三步，首先获取i的值，其次对i的值进行加1，最后将得到的新值写会到缓存中。
线程A首先得到了i的初始值100，但是还没来得及修改，就阻塞了，这时线程B开始了，它也得到了i的值，由于i的值未被修改，即使是被volatile修饰，主存的变量还没变化，那么线程B得到的值也是100，之后对其进行加1操作，得到101后，将新值写入到缓存中，再刷入主存中。根据可见性的原则，这个主存的值可以被其他线程可见。
问题来了，线程A已经读取到了i的值为100，也就是说读取的这个原子操作已经结束了，所以这个可见性来的有点晚，线程A阻塞结束后，继续将100这个值加1，得到101，再将值写到缓存，最后刷入主存，所以即便是volatile具有可见性，也不能保证对它修饰的变量具有原子性。

如下代码验证：

public class VolatileAtomDemo {
    // volatile不保证原子性

    // 原子性：保证数据一致性、完整性

    volatile int number = 0;

 

    public void addPlusPlus() {
        number++;

    }

 

    public static void main(String[] args) {
        VolatileAtomDemo volatileAtomDemo = new VolatileAtomDemo();

        for (int j = 0; j < 20; j++) {

            new Thread(() -> {

                for (int i = 0; i < 1000; i++) {

                    volatileAtomDemo.addPlusPlus();

                }

            }, String.valueOf(j)).start();

        }

 

        // 后台默认两个线程：一个是main线程，一个是gc线程

        while (Thread.activeCount() > 2) {
            Thread.yield();

        }

 

        // 如果volatile保证原子性的话，最终的结果应该是20000

        // 但是每次程序执行结果都不等于20000

        System.out.println(Thread.currentThread().getName() + "\tfinal number result = " + volatileAtomDemo.number);

    }

}

执行结果如下：多次执行结果证明volatile不保证原子性

 

 

 2.解决volatile原子不一致性的办法

（1）方法前加synchronized解决
    public synchronized void  addPlusPlus() {
        number++;

    }

（2）加锁解决
    // 使用锁保证数据原子性

    Lock lock = new ReentrantLock();

 

    public void addPlusPlus() {
        lock.lock();

        number++;

        lock.unlock();

    }

 

（3）原子类解决
// 使用原子类保证数据原子性

public class VolatileSolveAtomDemo {
    // 原子Integer类型，保证原子性

    private AtomicInteger atomicNumber = new AtomicInteger();

 

    // 底层通过CAS保证原子性

    public void addPlusPlus() {
        atomicNumber.getAndIncrement();

    }

 

    public static void main(String[] args) {
        VolatileSolveAtomDemo volatileSolveAtomDemo = new VolatileSolveAtomDemo();

        for (int j = 0; j < 20; j++) {
            new Thread(() -> {
                for (int i = 0; i < 1000; i++) {
                    volatileSolveAtomDemo.addPlusPlus();

                }

            }, String.valueOf(j)).start();

        }

 

        // 后台默认两个线程：一个是main线程，一个是gc线程

        while (Thread.activeCount() > 2) {
            Thread.yield();

        }

 

        // 因为volatile不保证原子性，所以选择原子类AtomicInteger来解决volatile不保证原子性问题

        // 最终每次程序执行结果都等于20000

        System.out.println(Thread.currentThread().getName() + "\tfinal number result = " + volatileSolveAtomDemo.atomicNumber.get());

    }

}

代码执行结果如下：

 

3.使用场景

  应用场景：单例模式的DCL双端检锁机制

单例模式：https://blog.csdn.net/weixin_41926301/article/details/95072899

4.CAS底层原理

1、CAS底层核心：Unsafe类
atomicInteger.getAndIncrement();

Unsafe是CAS核心类，由于java方法无法访问底层系统，需要通过本地（native）方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为java中CAS操作的执行依赖于Unsafe类的方法。

注意Unsafe类中所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务

2、变量valueOffset表示在内存中偏移地址
 

/**

     * Atomically increments by one the current value.

     *

     * @return the previous value

     */

    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);

    }

CAS全称为Compare-And-Swap，它是一条CPU并发原语。

它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的。

CAS并发原语体现在JAVA语言中就是sun.misc.Unsafe类中的各个方法。调用Unsafe中的CAS方法，JVM会帮我们实现出CAS汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致性问题。

3、变量value是用volatile修饰，保证了线程之间的内存可见性
    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;

        do {
            var5 = this.getIntVolatile(var1, var2);

        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;

}

getIntVolatile是native方法，所以可以直接操作：操作系统底层资源。

getIntVolatile这个方法可以获取主内存最新值

var1 AtomicInteger对象本身

var2 该对象值的引用地址

var5 通过var1 var2找出主内存中的真实值

用该对象当前值与var5比较

如果相同，更新var5+var4并且返回true

如果不同，继续取值比较，直到更新完成为止

4、CAS底层是汇编
Unsafe类中的compareAndSwapInt，是一个本地方法，该方法的实现位于unsafe.cpp中

5、CAS缺点
循环时间长CPU开销大
只能保证一个共享变量的原子操作
会引发ABA问题

6.ABA问题

1、什么是ABA问题
假设两个线程T1和T2访问同一个变量V，当T1访问变量V时，读取到V的值为A；此时线程T1被抢占了，T2开始执行，T2先将变量V的值从A变成B，然后又将变量V的值从B变成A；此时T1又抢占了主动权，继续执行，它发现V的值还是A，以为没有变化，所以就继续执行了。这个过程中，变量V从A变为B，再由B变为A就形象的称为ABA问题。

2、CAS会导致ABA问题
CAS会导致ABA问题。

CAS算法实现一个重要前提需要取出内存中某个时刻的数据并在当下时刻比较并替换，那么在这个时间差内会导致数据的变化。

比如说一个线程one从内存位置V中取出A，这个时候另一个线程two也从内存位置V中取出A，并且线程two进行了一些操作将值变成了B，然后线程two又将V位置的数据变成A，这时候线程one进行CAS操作时发现内存中仍然是A，然后线程one操作成功。

尽管线程one的CAS操作成功，但是并不代表这个过程就是没有问题