volatile的学习总结

1.volatile是Java虚拟机提供的轻量级的同步机制

保证可见性
不保证原子性
禁止指令重排

2. Java内存模型(JMM)

JMM(Java内存模型Java Memory Model，简称JMM)本身是一种抽象的概念，并不真实存在，它描述的是一组规则或规范，通过规范定义了程序中的各个变量(包括实例字段、静态字段和构成数组对象的元素)的访问方式。

JMM的同步规定：

线程解锁前，必须把共享变量的值刷新回主内存
线程加锁前，必须读取主内存的最新值到自己的工作内存
加锁解锁是同一把锁

由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存(有些地方称为栈空间)，工作内存时每个线程的私有数据区域，而Java内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作(读取赋值等)必须在工作内存中进行，首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回到主内存，不能直接操作主内存中的变量，各个线程的工作内存中存储着主内存中的变量副本拷贝，因此不同的线程间无法访问对方的工作内存，线程间的通信(传值)必须通过主内存来完成，其简要的访问过程如下图：

JMM的三大特性

JMM是线程安全性获得的保证。因为JMM具有如下特点：

可见性：从主内存拷贝变量后，如果某一个线程在自己的工作内存中对变量进行了修改，然后写回了主内存，其它线程能第一时间看到，这就叫作可见性。
原子性：不可分割，完整性，也即某个线程正在做某个具体业务时，中间不可以被加塞或者被分割
有序性：禁止指令重排，按照规定的顺序去执行

综上所述，volatile满足JMM三大特性中的两个，即可见性和有序性，volatile并不满足原子性，所以说volatile是轻量级的同步机制。

3. 代码验证Volatile的可见性

代码示例：

 /*** Created by salmonzhang on 2020/7/4.* 可见性代码实例*/public class VolatileDemo {public static void main(String[] args) {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(); }myData.addTo10();System.out.println(Thread.currentThread().getName() + "\t update number value:" + myData.number);},"Thread01").start();while (myData.number == 0) {//main线程一直在这里等待，直到number的值不再等于零}System.out.println(Thread.currentThread().getName()+"\t mission is over , number updated ...");}}class MyData{//    int number = 0; // 这里没有加volatilevolatile int number = 0; // 这里加了volatilepublic void addTo10() {this.number = 10;}}

没有加volatile的运行结果：

加了volatile的运行结果：

总结：如果不加volatile关键字，则主线程会进入死循环，加了volatile时主线程运行正常，可以正常退出，说明加了volatile关键字后，当有一个线程修改了变量的值，其它线程会在第一时间知道，当前值作废，重新从主内存中获取值。这种修改变量的值，让其它线程第一时间知道，就叫作可见性。

4. 代码验证Volatile不保证原子性

代码示例：

 /*** Created by salmonzhang on 2020/7/4.* 验证volatile不保证原子性* 原子性是什么意思：* 不可分割，完整性，也即某个线程正在做某个具体业务时，中间不可以被加塞或者被分割。* 需要整体完整，要么同时成功，要么同时失败。保证数据的原子一致性*/public class VolatileDemo2 {public static void main(String[] args) {MyData2 myData2 = new MyData2();for (int i = 1; i <= 20; i++){new Thread(() -> {for (int j = 0; j < 1000; j++) {myData2.addPlusPuls();}},String.valueOf(i)).start();}//需要等待上面20个线程全部执行完成后，再用main线程取得最终的结果值看看是多少？while (Thread.activeCount() > 2) { //后台默认有两个线程：GC线程和main线程Thread.yield();}System.out.println(Thread.currentThread().getName() + "finally number value = " + myData2.number);}}class MyData2{volatile int number = 0; // 这里加了volatilepublic void addPlusPuls() {number++;}}

运行结果：

从代码的运行结果会发现：会出现number最终的结果有可能出现不是20000的时候，这就证明了volatile不能保证原子性。

5. volatile不能保证原子性的原因和解决方案

为什么volatile不能保证原子性？

由于多线程进程调度的关系，在某一时间段出现了丢失写值的情况。因为线程切换太快，会出现后面的线程会把前面的线程的值刚好覆盖。

例如：Thread1和Thread2同时从主内存中读取number的值1到自己的工作内存，并同时进行了+1的动作，当Thread1将2写会主内存的时候，由于线程的调度原因，Thread2并没有第一时间知道Thread1已经将number的值改为了2，而是直接将Thread1改的number值进行覆盖，这样就会导致数据丢失。

解决方案：

2.1. 直接在addPlusPuls前面加上synchronized

class MyData2{volatile int number = 0; // 这里加了volatilepublic synchronized void addPlusPuls() {number++;}
}

但是为了保证一个number++的原子性直接用synchronized，感觉有点重，类似于“杀鸡用牛刀”

2.2 用atomic

class MyData2{AtomicInteger number = new AtomicInteger();public void addPlusPuls() {number.getAndIncrement();}
}

7. 有序性

计算机在执行程序时，为了提高性能，编译器的处理器通常会对指令做重排，一般有三种重排：
- 编译器的重排
- 指令并行的重排
- 内存系统的重排

单线程环境里确保程序最终执行的结果和代码执行的结果一致
处理器在进行重排序时，必须考虑指令之间的数据依懒性
多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证用的变量能否一致性是无法确定的，结果也是无法预测的

重排案例一：

public void mySort(){int x=11;//语句1int y=12;//语句2x=x+5;//语句3y=x*x;//语句4
}

计算机执行的顺序可能是：

1234

2134

1324

问题:
请问语句4可以重排后变成第一条码?
存在数据的依赖性，所以没办法排到第一个

重排案例二：

指令重排代码示例：

public class ReSortSeqDemo {int a = 0;boolean flag = false;public void method01() {a = 1;           // 这里的a和flag没有禁止指令重排，所以在多线程环境中就有可能出现问题flag = true;}public void method02() {if (flag) {a = a + 3;System.out.println("a = " + a);}}
}

这里的a和flag没有禁止指令重排，所以在多线程环境中就有可能出现问题，例如指令重排后，method01中的flag=true先被Thread1执行了，此时Thread2又抢占到了线程资源去执行method02()时，此时的运行结果就是有问题的。运行结果就是a = 3，而不是正常情况下的a = 4

7. 单例模式下可能存在线程不安全

代码示例：

public class SingletonDemo {private static SingletonDemo instance = null;private SingletonDemo(){System.out.println(Thread.currentThread().getName() + "\t 我是SingletonDemo的构造方法");};//synchronized 解决单例的多线程问题，会显得比较重，整个方法都被锁住了，不建议这么写public static SingletonDemo getInstance(){if (instance == null) {instance = new SingletonDemo();}return instance;}public static void main(String[] args) {//并发多线程后，会出现构造函数多次执行的情况for (int i = 1; i <= 10; i++){new Thread(() -> {SingletonDemo.getInstance();},String.valueOf(i)).start();}}
}

运行结果：

8. 单例模式下的volatile分析

1.代码示例：

public class SingletonDemo {private static volatile SingletonDemo instance = null; //加上volatile，禁止编译器指令重排private SingletonDemo(){System.out.println(Thread.currentThread().getName() + "\t 我是SingletonDemo的构造方法");};/*** DCL (double check Lock 双端检索机制)*/public static SingletonDemo getInstance(){if (instance == null) {synchronized (SingletonDemo.class) {if (instance == null) {instance = new SingletonDemo();}}}return instance;}public static void main(String[] args) {//并发多线程后，会出现构造函数多次执行的情况for (int i = 1; i <= 10; i++){new Thread(() -> {SingletonDemo.getInstance();},String.valueOf(i)).start();}}
}

总结：

如果没有加 volatile 就不一定是线程安全的，原因是指令重排序的存在，加入 volatile 可以禁止指令重排。
原因是在于某一个线程执行到第一次检测，读取到的 instance 不为 null 时，instance 的引用对象可能还没有完成初始化。

instance = new Singleton() 可以分为以下三步完成

 memory = allocate();  // 1.分配对象空间    instance(memory);     // 2.初始化对象instance = memory;    // 3.设置instance指向刚分配的内存地址，此时instance != null

步骤 2 和步骤 3 不存在依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变，因此这种优化是允许的。

发生重排

 memory = allocate();  // 1.分配对象空间  instance = memory;    //3.设置instance指向刚分配的内存地址，此时instance != null，但对象还没有初始化完成 instance(memory);     // 2.初始化对象

所以不加 volatile 返回的实例不为空，但可能是未初始化的实例

非常感谢您的耐心阅读，希望我的文章对您有帮助。欢迎点评、转发或分享给您的朋友或技术群。