文章目录
1、对volatile 的理解？JMM（Java 内存模型）JMM模型的三大特性：禁止指令排序线程安全性保证你在哪些地方用到过 volatile？单例2、CAS 你知道吗？CAS 底层原理？谈谈对 UnSafe 的理解？Unsafe类CAS 是什么？CAS 的缺点？ABA 问题是怎么产生的1、对volatile 的理解？
volatile 是 Java 虚拟机提供的轻量级的同步机制
保证可见性禁止指令排序不保证原子性
JMM（Java 内存模型）
JMM 本身是一种抽象的概念并不是真实存在，它描述的是一组规定或则规范，通过这组规范定义了程序中的访问方式。JMM 同步规定：
1、线程解锁前，必须把共享变量的值刷新回主内存
2、线程加锁前，必须读取主内存的最新值到自己的工作内存
3、加锁解锁是同一把锁
由于 JVM 运行程序的实体是线程，而每个线程创建时 JVM 都会为其创建一个工作内存，工作内存是每个线程的私有数据区域，而 Java 内存模型中规定所有变量的储存在主内存，主内存是共享内存区域，所有的线程都可以访问，但线程对变量的操作（读取赋值等）必须都工作内存进行看。
首先要将变量从主内存拷贝的自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，工作内存中存储着主内存中的变量副本拷贝，前面说过，工作内存是每个线程的私有数据区域，因此不同的线程间无法访问对方的工作内存，线程间的通信(传值)必须通过主内存来完成。
内存模型图
JMM模型的三大特性：
可见性原子性有序性（1）可见性，如果不加 volatile 关键字，则主线程会进入死循环，加 volatile 则主线程能够退出，说明加了 volatile 关键字变量，当有一个线程修改了值，会马上被另一个线程感知到，当前值作废，从新从主内存中获取值。对其他线程可见，这就叫可见性。
/*** @Author: cuzz* @Date: /4/16 21:29* @Description: 可见性代码实例*/public class VolatileDemo {public static void main(String[] args) {Data data = new Data();new Thread(() -> {System.out.println(Thread.currentThread().getName() + " coming...");try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}data.addOne(); // 调用System.out.println(Thread.currentThread().getName() + " updated...");}).start();while (data.a == 0) {// looping}System.out.println(Thread.currentThread().getName() + " job is done...");}}class Data {// int a = 0;volatile int a = 0;void addOne() {this.a += 1;}}
（2）原子性，发现下面输出不能得到 20000。
public class VolatileDemo {public static void main(String[] args) {// test01();test02();}// 测试原子性private static void test02() {Data data = new Data();for (int i = 0; i < 20; i++) {new Thread(() -> {for (int j = 0; j < 1000; j++) {data.addOne();}}).start();}// 默认有 main 线程和 gc 线程while (Thread.activeCount() > 2) {Thread.yield();}System.out.println(data.a);}}class Data {volatile int a = 0;void addOne() {this.a += 1;}}
（3）有序性
计算机在执行程序时，为了提高性能，编译器个处理器常常会对指令做重排，一般分为以下 3 种
1、编译器优化的重排
2、指令并行的重排
3、内存系统的重排单线程环境里面确保程序最终执行的结果和代码执行的结果一致处理器在进行重排序时必须考虑指令之间的数据依赖性多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证用的变量能否一致性是无法确定的，结果无法预测
public class ReSortSeqDemo {int a = 0;boolean flag = false;public void method01() {a = 1; // flag = true;// ----线程切换----flag = true;// a = 1;}public void method02() {if (flag) {a = a + 3;System.out.println("a = " + a);}}}
如果两个线程同时执行，method01 和 method02 如果线程 1 执行 method01 重排序了，然后切换的线程 2 执行 method02 就会出现不一样的结果。
禁止指令排序
volatile 实现禁止指令重排序的优化，从而避免了多线程环境下程序出现乱序的现象
先了解一个概念，内存屏障（Memory Barrier）又称内存栅栏，是一个 CPU 指令，他的作用有两个：
保证特定操作的执行顺序保证某些变量的内存可见性（利用该特性实现 volatile 的内存可见性）
由于编译器个处理器都能执行指令重排序优化，如果在指令间插入一条 Memory Barrier 则会告诉编译器和 CPU，不管什么指令都不能个这条 Memory Barrier 指令重排序，也就是说通过插入内存屏障禁止在内存屏障前后执行重排序优化。内存屏障另一个作用是强制刷出各种 CPU 缓存数据，因此任何 CPU 上的线程都能读取到这些数据的最新版本。
下面是保守策略下，volatile写插入内存屏障后生成的指令序列示意图：
下面是在保守策略下，volatile读插入内存屏障后生成的指令序列示意图：
线程安全性保证
工作内存与主内存同步延迟现象导致可见性问题可以使用 synchronzied 或 volatile 关键字解决，它们可以使用一个线程修改后的变量立即对其他线程可见对于指令重排导致可见性问题和有序性问题
可以利用 volatile 关键字解决，因为 volatile 的另一个作用就是禁止指令重排序优化
你在哪些地方用到过 volatile？单例
@NotThreadSafepublic class Singleton01 {private static Singleton01 instance = null;private Singleton01() {System.out.println(Thread.currentThread().getName() + " construction...");}public static Singleton01 getInstance() {if (instance == null) {instance = new Singleton01();}return instance;}public static void main(String[] args) {ExecutorService executorService = Executors.newFixedThreadPool(10);for (int i = 0; i < 10; i++) {executorService.execute(()-> Singleton01.getInstance());}executorService.shutdown();}}
双重锁单例：
public class Singleton02 {private static volatile Singleton02 instance = null;private Singleton02() {System.out.println(Thread.currentThread().getName() + " construction...");}public static Singleton02 getInstance() {if (instance == null) {synchronized (Singleton01.class) {if (instance == null) {instance = new Singleton02();}}}return instance;}public static void main(String[] args) {ExecutorService executorService = Executors.newFixedThreadPool(10);for (int i = 0; i < 10; i++) {executorService.execute(()-> Singleton02.getInstance());}executorService.shutdown();}}
如果没有加 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 返回的实例不为空，但可能是未初始化的实例。
2、CAS 你知道吗？CAS 底层原理？谈谈对 UnSafe 的理解？
public class CASDemo {public static void main(String[] args) {AtomicInteger atomicInteger = new AtomicInteger(666);// 获取真实值，并替换为相应的值boolean b = pareAndSet(666, );System.out.println(b); // trueboolean b1 = pareAndSet(666, );System.out.println(b1); // falseatomicInteger.getAndIncrement();}}
getAndIncrement()方法
/*** Atomically increments by one the current value.** @return the previous value*/public final int getAndIncrement() {return unsafe.getAndAddInt(this, valueOffset, 1);}
引出一个问题：UnSafe 类是什么？我们先看看AtomicInteger 就使用了Unsafe 类。
public class AtomicInteger extends Number implements java.io.Serializable {private static final long serialVersionUID = 6214790243416807050L;// setup to use pareAndSwapInt for updatesprivate static final Unsafe unsafe = Unsafe.getUnsafe();private static final long valueOffset;static {try {// 获取下面 value 的地址偏移量valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));} catch (Exception ex) {throw new Error(ex); }}private volatile int value;// ...}
Unsafe类
Unsafe 是 CAS 的核心类，由于 Java 方法无法直接访问底层系统，而需要通过本地（native）方法来访问， Unsafe 类相当一个后门，基于该类可以直接操作特定内存的数据。Unsafe 类存在于 sun.misc 包中，其内部方法操作可以像 C 指针一样直接操作内存，因为 Java 中 CAS 操作执行依赖于 Unsafe 类。变量 vauleOffset，表示该变量值在内存中的偏移量，因为 Unsafe 就是根据内存偏移量来获取数据的。变量 value 用 volatile 修饰，保证了多线程之间的内存可见性。CAS 是什么？
CAS 的全称 Compare-And-Swap，它是一条 CPU 并发。
它的功能是判断内存某一个位置的值是否为预期，如果是则更改这个值，这个过程就是原子的。
CAS 并发原体现在 JAVA 语言中就是 sun.misc.Unsafe 类中的各个方法。调用 UnSafe 类中的 CAS 方法，JVM 会帮我们实现出 CAS 汇编指令。这是一种完全依赖硬件的功能，通过它实现了原子操作。由于 CAS 是一种系统源语，源语属于操作系统用语范畴，是由若干条指令组成，用于完成某一个功能的过程，并且原语的执行必须是连续的，在执行的过程中不允许被中断，也就是说 CAS 是一条原子指令，不会造成所谓的数据不一致的问题。
分析一下 getAndAddInt 这个方法
// unsafe.getAndAddIntpublic final int getAndAddInt(Object obj, long valueOffset, long expected, int val) {int temp;do {temp = this.getIntVolatile(obj, valueOffset); // 获取快照值} while (!pareAndSwap(obj, valueOffset, temp, temp + val)); // 如果此时 temp 没有被修改，就能退出循环，否则重新获取return temp;}
CAS 的缺点？
1、循环时间长开销很大
如果 CAS 失败，会一直尝试，如果 CAS 长时间一直不成功，可能会给 CPU 带来很大的开销（比如线程数很多，每次比较都是失败，就会一直循环），所以希望是线程数比较小的场景。
2、只能保证一个共享变量的原子操作
对于多个共享变量操作时，循环 CAS 就无法保证操作的原子性。
3、引出 ABA 问题
原子类 AtomicInteger 的 ABA 问题谈一谈？原子更新引用知道吗？
原子引用：
public class AtomicReferenceDemo {public static void main(String[] args) {User cuzz = new User("cuzz", 18);User faker = new User("faker", 20);AtomicReference<User> atomicReference = new AtomicReference<>();atomicReference.set(cuzz);System.out.println(pareAndSet(cuzz, faker)); // trueSystem.out.println(atomicReference.get()); // User(userName=faker, age=20)}}
ABA 问题是怎么产生的
/*** @program: learn-demo* @description: ABA* @author: cuzz* @create: -04-21 23:31**/public class ABADemo {private static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);public static void main(String[] args) {new Thread(() -> {pareAndSet(100, 101);pareAndSet(101, 100);}).start();new Thread(() -> {// 保证上面线程先执行try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}pareAndSet(100, );System.out.println(atomicReference.get()); // }).start();}}
当有一个值从 A 改为 B 又改为 A，这就是 ABA 问题。
时间戳原子引用：
package com.cuzz.thread;import java.util.concurrent.atomic.AtomicReference;import java.util.concurrent.atomic.AtomicStampedReference;/*** @description: ABA* @author: cuzz* @create: -04-21 23:31**/public class ABADemo2 {private static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 1);public static void main(String[] args) {new Thread(() -> {int stamp = atomicStampedReference.getStamp();System.out.println(Thread.currentThread().getName() + " 的版本号为：" + stamp);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}pareAndSet(100, 101, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1 );pareAndSet(101, 100, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1 );}).start();new Thread(() -> {int stamp = atomicStampedReference.getStamp();System.out.println(Thread.currentThread().getName() + " 的版本号为：" + stamp);try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}boolean b = pareAndSet(100, , stamp, stamp + 1);System.out.println(b); // falseSystem.out.println(atomicStampedReference.getReference()); // 100}).start();}}
我们先保证两个线程的初始版本为一致，后面修改是由于版本不一样就会修改失败。
