volatile是Java提供的轻量级的同步机制，主要有三个特性：

1.保证内存可见性
2.不保证原子性
3.禁止指令重排序

1.保证内存可见性

volatile是Java提供的轻量级的同步机制，保证了可见性，不保证原子性。了解volatile工作机制，首先要对Java内存模型（JMM）有初步的认识：

• 每个线程创建时，JVM会为其创建一份私有的工作内存（栈空间），不同线程的工作内存之间不能直接互相访问。JMM规定所有的变量都存在主内存，主内存是共享内存区域，所有线程都可以访问
• 线程对变量进行读写，会从主内存拷贝一份副本到自己的工作内存，操作完毕后刷新到主内存。所以，线程间的通信要通过主内存来实现。

volatile的作用是：线程对副本变量进行修改后，其他线程能够立刻同步刷新最新的数值。这个就是可见性。

2.可见性验证

我们来看一个例子：

package com.bruceliu.demo15;import java.util.concurrent.TimeUnit;/*** @BelongsProject: Thread0509* @BelongsPackage: com.bruceliu.demo15* @Author: bruceliu* @QQ:1241488705* @CreateTime: 2020-05-13 23:16* @Description: TODO*/
public class VolatileDemo {int x = 0;//注意：这里的b没有被volatile修饰boolean b = false;/*** 写操作*/private void write() {x = 5;b = true;System.out.println("x=>" + x);System.out.println("b =>" + b);}/*** 读操作*/private void read() {//如果b=false的话，就会无限循环，直到b=true才会执行结束，会打印出x的值while (!b) {}System.out.println("x=" + x);}public static void main(String[] args) throws Exception {final VolatileDemo volatileDemo = new VolatileDemo();//线程1执行写操作Thread thread1 = new Thread(new Runnable() {public void run() {volatileDemo.write();}});//线程2执行读操作Thread thread2 = new Thread(new Runnable() {public void run() {volatileDemo.read();}});//我们让线程2的读操作先执行thread2.start();//睡1毫秒，为了保证线程2比线程1先执行TimeUnit.MILLISECONDS.sleep(1);//再让线程1的写操作执行thread1.start();thread1.join();thread2.join();//等待线程1和线程2全部结束后，打印执行结束System.out.println("执行结束");}
}

注意我们的b没有用volatile修饰，我们先启动了线程2的读操作，后启动了线程1的写操作，由于线程1和线程2会保存x和b的副本到自己的工作内存中，线程2执行后，由于他副本b=false，所以会进入到无限循环中，线程1执行后修改的也是自己副本中的b=true，然而线程2无法立即察觉到，所以执行上面代码后，不会打印“执行结束”，因为线程2一直在执行！

运行之后会一直出于运行状态，并且没有打印“执行结束”

此时的流程会是这样子

给b加了volatile关键字修饰后，线程1对b做了修改，然后会立即更新内存中的值，线程2通过嗅探发现自己的副本已经过期了，然后重新从内存中拿到b=true的值，然后跳出while循环，执行结束！

我们知道volatile关键字的作用是保证变量在多线程之间的可见性，它是java.util.concurrent包的核心，没有volatile就没有这么多的并发类给我们使用.

3.原子性验证

看下面一段代码，number变量加了volatile修饰。创建了10个子线程，每个线程循环1000次执行number++。

package com.bruce.demo8;import java.util.concurrent.TimeUnit;/*** @BelongsProject: SingleTon-2020* @BelongsPackage: com.bruce.demo8* @CreateTime: 2020-12-10 23:08* @Description: TODO*/
public class Demo8 {static class MyTest {public volatile int number = 0;public void incr(){number++;}}public static void main(String[] args) {MyTest myTest = new MyTest();for (int i = 1; i <= 10; i++){new Thread(() -> {for (int j = 1; j <= 1000; j++){myTest.incr();}}, "Thread"+String.valueOf(i)).start();}try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}//等线程执行结束了，输出number值System.out.println("当前number：" + myTest.number);}
}

按理说number最终应该是10000，但是这边执行后，结果如下：

4.原子性问题解决

方法一：使用 synchronized 关键字

//给函数增加synchronized修饰，相当于加锁了public synchronized void incr(){number++;}

结果如下：

方法二：使用AtomicInteger

public class Demo8 {static class MyTest {public volatile AtomicInteger number = new AtomicInteger();public void incr(){number.getAndIncrement();}}public static void main(String[] args) {MyTest myTest = new MyTest();for (int i = 1; i <= 10; i++){new Thread(() -> {for (int j = 1; j <= 1000; j++){myTest.incr();}}, "Thread"+String.valueOf(i)).start();}try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}//等线程执行结束了，输出number值System.out.println("当前number：" + myTest.number);}
}

5.禁止指令重排序

体现了JMM的有序性

6.JMM谈谈你的理解

6.1.基本概念

JMM 本身是一种抽象的概念并不是真实存在，它描述的是一组规定或则规范，通过这组规范定义了程序中的访问方式。

6.2.JMM同步规定

6.2.1.可见性

可见性：一个线程对某一共享变量修改之后，另一个线程要立即获取到修改后的结果。

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

由于 JVM 运行程序的实体是线程，而每个线程创建时 JVM 都会为其创建一个工作内存，工作内存是每个线程的私有数据区域，而 Java 内存模型中规定所有变量的储存在主内存，主内存是共享内存区域，所有的线程都可以访问，但线程对变量的操作（读取赋值等）必须都工作内存进行看。

首先要将变量从主内存拷贝的自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，工作内存中存储着主内存中的变量副本拷贝，前面说过，工作内存是每个线程的私有数据区域，因此不同的线程间无法访问对方的工作内存，线程间的通信(传值)必须通过主内存来完成。

内存模型图

6.2.2.原子性

原子性： 不可分割，完整性，也就是说某个线程正在做某个具体业务时，中间不可以被加塞或者被分割，需要具体完成，要么同时成功，要么同时失败。

数据库也经常提到事务具备原子性!

在putfield时，其他线程挂起，没有及时得到主内存的值改变消息

n++在多线程下是非线程安全的，如何不加synchronized解决？

• 使用原子类(java.util.concurrent.atomic)
• 为什么使用了原子类可以解决？原理是什么？CAS

6.2.3.有序性

计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令做重排，一般分一下3种：

源代码->编译器优化的重排->指令并行的重排->内存系统的重排->最终执行的指令

单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致。

处理器在进行重排序时必须考虑指令之间的数据依赖性。

多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。

指令重排 - example 1

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

按照正常单线程环境，执行顺序是 1 2 3 4
但是在多线程环境下，可能出现以下的顺序：

2 1 3 41 3 2 4

上述的过程就可以当做是指令的重排，即内部执行顺序，和我们的代码顺序不一样。但是指令重排也是有限制的，即不会出现下面的顺序

4 3 2 1

因为处理器在进行重排时候，必须考虑到指令之间的数据依赖性

因为步骤 4：需要依赖于 y的申明，以及x的申明，故因为存在数据依赖，无法首先执行

例子
int a,b,x,y = 0

线程1	线程2
x = a;	y = b;
b = 1;	a = 2;
x = 0; y = 0

因为上面的代码，不存在数据的依赖性，因此编译器可能对数据进行重排

线程1	线程2
b = 1;	a = 2;
x = a;	y = b;
x = 2; y = 1

这样造成的结果，和最开始的就不一致了，这就是导致重排后，结果和最开始的不一样，因此为了防止这种结果出现，volatile就规定禁止指令重排，为了保证数据的一致性

指令重排 - example 2
比如下面这段代码

public class ResortSeqDemo {int a= 0;boolean flag = false;public void method01() {a = 1;flag = true;}public void method02() {if(flag) {a = a + 5;System.out.println("reValue:" + a);}}
}

我们按照正常的顺序，分别调用method01() 和 method02() 那么，最终输出就是 a = 6

但是如果在多线程环境下，因为方法1 和 方法2，他们之间不能存在数据依赖的问题，因此原先的顺序可能是

a = 1;
flag = true;a = a + 5;
System.out.println("reValue:" + a);

但是在经过编译器，指令，或者内存的重排后，可能会出现这样的情况

flag = true;a = a + 5;
System.out.println("reValue:" + a);a = 1;

也就是先执行 flag = true后，另外一个线程马上调用方法2，满足 flag的判断，最终让a + 5，结果为5，这样同样出现了数据不一致的问题

为什么会出现这个结果：多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。

这样就需要通过volatile来修饰，来禁止指令重排序保证线程安全性

6.3.Volatile针对指令重排做了啥

Volatile实现禁止指令重排优化，从而避免了多线程环境下程序出现乱序执行的现象
首先了解一个概念，内存屏障（Memory Barrier）又称内存栅栏，是一个CPU指令，它的作用有两个：

• 保证特定操作的顺序
• 保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）

由于编译器和处理器都能执行指令重排的优化，如果在指令间插入一条Memory Barrier则会告诉编译器和CPU，不管什么指令都不能和这条Memory Barrier指令重排序，也就是说 通过插入内存屏障禁止在内存屏障前后的指令执行重排序优化。 内存屏障另外一个作用是刷新出各种CPU的缓存数，因此任何CPU上的线程都能读取到这些数据的最新版本。

也就是过在Volatile的写 和 读的时候，加入屏障，防止出现指令重排的

7.你在哪些地方用过Volatile？

工作内存与主内存同步延迟现象导致的可见性问题

• 可通过synchronized或volatile关键字解决，他们都可以使一个线程修改后的变量立即对其它线程可见，对于指令重排导致的可见性问题和有序性问题
• 可以使用volatile关键字解决，因为volatile关键字的另一个作用就是禁止重排序优化

举例：

public class LazySafe {private LazySafe(){}//对象加上了volatile关键字是为了保证变量的可见性，防止指令重排序//第二个线程拿到的可能是半实列化的对象，所以要加volatile防止指令重排序private volatile static LazySafe lazySafe;public static  LazySafe getInstance(){if(lazySafe==null){//双重判定synchronized (LazySafe.class){if(lazySafe==null){lazySafe=new LazySafe(); //不是原子性的！}}}return lazySafe;}
}

DCL（双端检锁）机制不一定是线程安全的，原因是有指令重排的存在，加入volatile可以禁止指令重排

原因是在某一个线程执行到第一次检测的时候，读取到 instance 不为null，instance的引用对象可能没有完成实例化。因为 instance = new SingletonDemo()；可以分为以下三步进行完成：

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、初始化对象

这样就会造成什么问题呢？

也就是当我们执行到重排后的步骤2，试图获取instance的时候，会得到null，因为对象的初始化还没有完成，而是在重排后的步骤3才完成，因此执行单例模式的代码时候，就会重新在创建一个instance实例

指令重排只会保证串行语义的执行一致性（单线程），但并不会关系多线程间的语义一致性

所以当一条线程访问instance不为null时，由于instance实例未必已初始化完成，这就造成了线程安全的问题

所以需要引入volatile，来保证出现指令重排的问题，从而保证单例模式的线程安全性！