volatile的使用以及引起的问题解决方法

volatile是什么？有什么特性？

1、volatile是java虚拟机提供的轻量级的同步机制

三大特性如下：

1、保证可见性 

2、不保证原子性

3、禁止指令重排

JMM内存模型是如何实现可见性？

JVM运行程序实体是线程，线程创建时JVM都会为其开辟一个工作内存，工作内存是每个线程私有的数据区域，而java内存模型中规定所有变量都存在主内存中 (主内存：相当于电脑上的内存条,有8G、16G等...)线程对变量的操作(读取和赋值)必须在自己的工作内存中进行，

首先要将变量从主内存中拷贝到自己的工作内存空间，然后对变量进行操作，操作完后再将变量写会主内存。  如下图：

 

                                              

                                                     图1                                                                                                                            图2

1、由于添加了volatile的缘故，线程A对主内存共享变量的操作线程B是可见的，这就体现了volatile三大特性之一的 “保证可见性”

2、不保证原子性的原因：假如主内存有一个变量值为 age=18,  线程A和线程B分别将主内存的变量拷贝到自己的工作内存中， 线程A将age的值修改成 20，

然后在写回主内存，此时主内存的值为 20；由于各种原因，线程B网络故障导致修改时间比线程A慢了十几秒；而此时线程A又把主内存中的 20 改成 18，这时线程B

通过CAS(ComPareAndSwap)：比较并交换)发现主内存中的值还是 18；于是把 18 改成了 22，虽然修改成功了，但并不表示没有问题了；CAS操作引起了ABA的问题。

3、禁止指令重排：多线程环境下线程交替执行，由于编译器优先重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测，用volatile修饰变量

可防止指令重排

 验证volatile可见性、解决volatile不保证原子性的case

package com.company;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

class MyData {
    volatile int number = 0;//没加volatile的时候不保证可见性

    public void addTo() {
        this.number = 60;
    }

    //此時已經添加了volatile，不保证原子性
    public void addNumber() {
        number++;
    }

    //AtomicInteger解决原子性问题
    AtomicInteger atomicInteger = new AtomicInteger();//不传参数，底层源码默认是 0

    public void addPlus() {
        atomicInteger.getAndIncrement();//Atomically increments by one the current value.   源码注释每调一次就会自增 1 
    }
}

/**
 * 1.0  验证 volatile 的可见性
 * 1.1  假设int number = 0,number变量不添加volatile关键字修饰，没有可见性
 * 1.2  添加了volatile,可以解决可见性问题
 * <p>
 * 2.0  volatile 不保证原子性
 */
public class VolatileDemo {
    public static void main(String[] args) {
        atomicIntegerSee();
        SeeVolatile();
    }

    /**
     * AtomicInteger保证原子性
     */
    public static void atomicIntegerSee() {
        MyData myData = new MyData();
        /**
         * 验证volatile不保证原子性
         * number添加了volatile不保证原子性
         * 20加到1000，答案是20000；但volatile不保证原子性
         * 如何解决volatile不保证原子性问题？
         *   方法一：在方法上面添加 synchronized 关键字修饰，但每次访问只能有一个线程；导致并发性下降
         *   方法二：使用 AtomicInteger  即可以保证原子性，又不会降低并发量
         */
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 1; j <= 1000; j++) {
                    myData.addNumber();//volatile不保证原子性，所以最终结果不会是20000；会比20000小；有可能侥幸是20000
                    myData.addPlus();// 20个线程怎么加都是20000.能解决原子性的问题
                }
            }, String.valueOf(i)).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + "\t volatile number value is: " + myData.number);
        System.out.println(Thread.currentThread().getName() + "\t AtomicInteger number value is: " + myData.atomicInteger);
    }

    /**
     * 1.0  验证volatile的可见性
     */
    public static void SeeVolatile() {
        MyData myData = new MyData();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t come in");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }//线程休眠3秒钟
            myData.addTo();//这时候number已经变成60，但由于没有添加volition关键字，其他线程并不知道number已经变成60
            System.out.println(Thread.currentThread().getName() + "\t updata number:  " + myData.number);//此时拿到的number已经是修改完后写回主内存的number
        }, "AAA").start();

        while (myData.number == 0) {
            //如果取到的number等于0，main线程就会执行里面的内容；但此时main线程已经等于60；所以线程一直处于等待状态，下面的语句无法输出
        }
        System.out.println(Thread.currentThread().getName() + "\t main Thread number is fish,main get number: " + myData.number);
    }
}

 解决CAS引起的ABA问题

package com.company;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * 版本号的原子引用
 * 解决ABA问题：AtomicStampedReference
 */
public class ABADemo {
    static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference(100, 1);

    public static void main(String[] args) {
        System.out.println("=================================以下是ABA问题的产生=======================================");
        new Thread(() -> {
            atomicReference.compareAndSet(100, 101);
            atomicReference.compareAndSet(101, 100);
        }, "t1").start();
        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicReference.compareAndSet(100, 2019) + "\t " + atomicReference.get());//修改成功，但t1中间修改了两次又改回100，所以存在ABA问题
        }, "t2").start();
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }//暂停两秒钟，保证上面的t1和t2 线程都操作完
        System.out.println("=================================以下是ABA问题的解决=======================================");
        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();//获取当前版本号
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }//休眠1秒，让t4也获得当前版本号
            System.out.println(Thread.currentThread().getName() + "\t 第一版本号为：" + stamp);
            atomicStampedReference.compareAndSet(100, 101, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t 第二版本号为：" + atomicStampedReference.getStamp() + "\t 當前主內存中的值為：" + atomicStampedReference.getReference());
            atomicStampedReference.compareAndSet(101, 100, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t 第三版本号为：" + atomicStampedReference.getStamp() + "\t 當前主內存中的值為：" + atomicStampedReference.getReference());
        }, "t3").start();
        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();//获取当前版本号
            System.out.println(Thread.currentThread().getName() + "\t 第一版本号：" + stamp);
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }//休眠3秒，让t3完成一次ABA的操作
            boolean result = atomicStampedReference.compareAndSet(100, 2019, stamp, stamp + 1);//修改失败，版本号不匹配
            /*boolean result=atomicStampedReference.compareAndSet(100,2019,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);*/
            System.out.println(Thread.currentThread().getName() + "\t 是否修改成功：" + result + "\t 当前最新版本为：" + atomicStampedReference.getStamp());
            System.out.println(Thread.currentThread().getName() + "\t 当前主内存的最新值为：" + atomicStampedReference.getReference());
        }, "t4").start();
    }
}

 

 CAS优缺点

优点：

利用CPU的CAS指令，同时借助JNI来完成Java的非阻塞算法。其它原子操作都是利用类似的特性完成的。而整个J.U.C都是建立在CAS之上的，因此对于synchronized阻塞算法，J.U.C在性能上有了很大的提升。

缺点：

1、ABA问题。当第一个线程执行CAS操作，尚未修改为新值之前，内存中的值已经被其他线程连续修改了两次，使得变量值经历 A -> B -> A的过程。

2、循环时间长开销大。如果有很多个线程并发，CAS自旋可能会长时间不成功，会增大CPU的执行开销。

3、只能对一个变量进原子操作。JDK1.5之后，新增AtomicReference类来处理这种情况，可以将多个变量放到一个对象中。