面试题：
1、请谈谈你对volatile的理解？
volatile是Java虚拟机提供的轻量级的同步机制1.保证可见性2.不保证原子性3.禁止指令重排
2、JMM你谈谈?Java内存模型 
3、你在哪些地方用到过volatile?单例模式CAS底层代码

目录

一、概述

 1、可见性

2、原子性

3、有序性

4、总结

---

一、概述

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

JMM关于同步的规定：

1、线程解锁前，必须把共享变量的值刷新回主内存

2、线程加锁前，必须读取主内存的最新值到自己的工作内存

3、加锁解锁是同一把锁

主内存:内存8G硬件内存条
自己的工作内存:各自线程的工作内存工作速率:硬盘<内存<CPU
CPU与内存之间读取有一个缓存cache;
CPU计算数据计算完，但是内存数据还没拿到，此时CPU干等着?CPU和内存之间有一个缓存来临时存储数据。
可以通过CPU-Z软件来查看，有一个缓存工具栏。

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

 1、可见性

这种第一时间通知内存修改的消息机制，就叫Java内存模型中的可见性。可以理解为及时通知。

可见性的代码验证

import java.util.concurrent.TimeUnit;public class VolatileDemo {public static void main(String[] args) {MyData myData = new MyData();new Thread(() -> {System.out.println(Thread.currentThread().getName() + "\t in");try {TimeUnit.SECONDS.sleep(3);} catch (Exception e) {e.printStackTrace();}myData.add();System.out.println(Thread.currentThread().getName() + "\t over ,num=" + myData.num);}, "aa").start();while (myData.num == 0) {// main线程一直在此等待，直到num不等于0}System.out.println(Thread.currentThread().getName() + "\t over");}}class MyData {int num = 0;public void add() {this.num = 60;}
}

结果如下并且main线程一直没结束，没人通知它num值变更了。

aa     in
aa     over ,num=60

修改程序，增加volatile：

import java.util.concurrent.TimeUnit;public class VolatileDemo {public static void main(String[] args) {MyData myData = new MyData();new Thread(() -> {System.out.println(Thread.currentThread().getName() + "\t in");try {TimeUnit.SECONDS.sleep(3);} catch (Exception e) {e.printStackTrace();}myData.add();System.out.println(Thread.currentThread().getName() + "\t over ,num=" + myData.num);}, "aa").start();while (myData.num == 0) {// main线程一直在此等待，直到num不等于0}System.out.println(Thread.currentThread().getName() + "\t over ,num=" + myData.num);}}class MyData {volatile int num = 0;public void add() {this.num = 60;}
}

此时结果：

aa	 in
aa	 over ,num=60
main	 over ,num=60

线程aa中把num值变更了，及时通知主线程main，此为JMM的可见性。

通过前面对JMM介绍，我们知道各个线程对主内存中共享变量的操作都是各个线程各自拷贝到自己的工作内存进行操作后再写回到主内存中的。

这就可能存在一个线程aa修改了共享变量X的值还未写回主内存时，另外一个线程bb又对主内存中同一个共享变量X进行操作，但此时aa线程工作内存中的共享变量X对bb来说并不可见，这种工作内存与主内存同步延迟现象就造成了可见性问题。

2、原子性

2.1、原子性指的是什么意思？

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

2.2、volatile不保证原子性

验证不保证原子性

public class VolatileDemo {public static void main(String[] args) {MyData myData = new MyData();for (int i = 1; i <= 20; i++) {new Thread(() -> {for (int j = 1; j <= 1000; j++) {myData.addPlus();}}, String.valueOf(i)).start();}while (Thread.activeCount() > 2) {Thread.yield();}// 上面20个线程计算完最终结果System.out.println(Thread.currentThread().getName() + "\t num=" + myData.num);}}class MyData {volatile int num = 0;public void add() {this.num = 60;}public void addPlus() {this.num++;}
}

结果：main     num=16919       每一次运行结果都不一致。

2.3、如何解决原子性？

        1、加synchronized

        2、使用JUC下的AtomicInteger解决

import java.util.concurrent.atomic.AtomicInteger;public class VolatileDemo {public static void main(String[] args) {MyData myData = new MyData();for (int i = 1; i <= 20; i++) {new Thread(() -> {for (int j = 1; j <= 1000; j++) {myData.addPlus();myData.addAtomic();}}, String.valueOf(i)).start();}while (Thread.activeCount() > 2) {Thread.yield();}// 上面20个线程计算完最终结果System.out.println(Thread.currentThread().getName() + "\t num=" + myData.num);System.out.println(Thread.currentThread().getName() + "\t atomicInteger=" + myData.atomicInteger);}}class MyData {volatile int num = 0;public void add() {this.num = 60;}public synchronized void addPlus() {this.num++;}AtomicInteger atomicInteger = new AtomicInteger();public void addAtomic() {atomicInteger.getAndIncrement();}}

结果：

main     num=20000
main     atomicInteger=20000

3、有序性

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

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

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

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

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

public class ReSortSeqDemo {int a = 0;boolean flg = false;public void m1() {a = 1;flg = true;}// 多线程环境中线程交替执行，由于编译器优化重排的存在，// 两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。
// m1方法中的a=1和flg=true;的执行顺序因为有编译器重排的存在，有可能flg=true先执行，后执行a=1;// flg=true先执行时，突然m2方法线程执行,此时a=0+5;否则有可能a=1+5;public void m2() {if (flg) {a = a + 5;}}}

4、总结

        volatile实现禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象

先了解一个概念，内存屏障(Memory Barrier)又称内存栅栏，是一个CPU指令，它的作用有两个：

一是保证特定操作的执行顺序。

二是保证某些变量的内存可见性(利用该特性实现volatile的内存可见性)

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

        对volatile变量进行写操作时，会在写操作后加入一条store屏障指令，将工作内存中的共享变量值刷新回主内存。

        对volatile变量进行读操作时，会在读操作前加入一条load屏障指令，从主内存中读取共享变量。

volatile可应用在单例模式下

单例模式

干我们这行，啥时候懈怠，就意味着长进的停止，长进的停止就意味着被淘汰，只能往前冲，直到凤凰涅槃的一天！