JVM系列之JMM内存模型
JVM系列之JMM内存模型
这篇博文之所以和“JVM系列之内存与垃圾回收篇”同期出，是因为我觉得如果单学习JVM的内存部分可能会让大部分人有点不知所云，毕竟不是“JVM系列之性能监控与调优篇”，所以我结合了线程安全和JVM数据运行区域下的变量去说明JMM内存模型的核心作用，结合“JVM系列之内存与垃圾回收篇”，可以让JVM更容易理解。
文章目录
- JVM系列之JMM内存模型
- 前言
- 第一章JMM的基本概要
-
- # JMM是什么？
- # 什么环境下会有数据安全问题？
- 第二章JAVA变量与线程安全
-
- # 变量
- # 虚拟机栈存储的变量与线程安全
- # 堆存储的变量与线程安全
- # 方法区存储的变量与线程安全
- # final与线程安全
- 第三章JMM与线程安全
-
- # 原子性
- # 指令重排
- # 可见性
- # 有序性
- # JMM中的happens-before 原则
- # volatile内存语义
- # volatile的可见性
- # volatile禁止重排优化
前言
“JVM系列之JMM内存模型”使用代码和实测的手法来说明知识点，内容是从用户请求到JVM去解析的，涉及变量，WEB服务器，多线程，JVM数据运行区域等知识点，如果有一些知识点有异议，欢迎指出！
第一章JMM的基本概要
# JMM是什么？
- Java内存模型(即Java Memory Model，简称JMM)本身是一种抽象的概念，并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量的访问方式，通过这组规则来决定一个线程对共享变量的写入何时对另一个线程可见，这组规则也称为Java内存模型（即JMM），简单来说，就是在并发环境下（用户并发访问或者程序使用多线程编程），你通过锁或者一些关键字（synchronized或者volatile）来解决并发问题时，实际上就是你通过的这些手段去触发JMM定义的规则（变量是否可见或者操作是否单一）去保证程序在并发环境下对变量操作的安全
# 什么环境下会有数据安全问题？
也许你觉得这个问题放到这里有点不合适，但是上面提到JMM主要是与变量（数据）有关，所以知道什么环境会导致数据安全，而JMM是怎么控制这个问题的，是了解JMM的核心。
- 数据安全问题可以由两个方面造成：①用户并发访问②程序使用多线程编程
计算机或者服务器安装JDK其本质就是在计算机上配置一个JVM环境，而我们都知道JAVA程序的启动都需要依赖WEB服务器，原来的WEB项目是通过外置的WEB服务器启动，而现在的SpringBoot项目是通过打包成jar时内置一个WEB服务器的方式。
WEB服务器主要有两大作用，第一就是接收用户请求，并把请求转到配置在自身服务器内的程序中；第二个就是线程池管理。
① 程序运行的实体是JVM进程中的线程，这个线程主要是对JVM进行变量操作，这个线程是通过WEB服务器去创建的，原来的WEB服务器内可以配置多个程序，然后共用一个JVM，而现在的SpringBoot项目通过内置的WEB服务器，只能一个WEB服务器对应一个程序，一个项目对应一个JVM。
演示验证：一个WEB服务器对应一个JVM进程，一个WEB服务器内可以配置多个项目，共用一个JVM进程
演示验证：SpringBoot项目一个项目对应一个JVM进程
②用户访问程序的实质是通过WEB服务器创建线程去通过程序这个线程对JVM进行变量操作，这一结论就解释了①用户并发访问会造成多个线程同时对JVM的变量进行操作，如果操作的变量会有线程不安全问题（下面会介绍哪些变量会线程不安全）就会导致数据不安全问题。而程序使用多线程编程的实质是操作WEB服务器的线程池去创建线程去执行对应的逻辑代码，多线程的对JVM进行数据操作（存储或者取出）这一结论就解释了②程序使用多线程编程会造成数据不安全问题
演示验证：用户访问程序会在JVM进程内创建线程的实质（线程有限，超过排队）
- 每个线程创建时JVM都会为其创建一个工作内存(因为JVM中可以存储变量，而又是线程独享的只有虚拟机栈，所以工作内存也可以称为栈空间)，用于存储线程私有的数据，而Java内存模型中规定所有变量（这里的变量指的是存储在堆和方法区的变量，虚拟机栈内也可以存储变量）都存储在主内存（堆和方法区），主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作(读取赋值等)必须在工作内存中进行，首先要将变量从主内存拷贝到 自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存（这就有一个时间差的问题导致的数据不安全），不能直接操作主内存中的变量，工作内存中存储着主内存中的变量副本拷贝，前面说过，工作内存是每个线程的私有数据区域，因此不同的线程间无法访问对方的工作内存，线程间的通信(传值)必须通过主内存来完成。
第二章JAVA变量与线程安全
# 变量
- 变量的组成：①变量的数据类型 ②变量名
变量的分类：按照数据类型分：①基本数据类型（值变量） ②引用类型（引用变量，注意区分引用变量和引用变量的对象的区别）
按照在类中的声明的位置分：① 成员变量：在使用之前，都经历过默认初始化赋值
类变量：linking的prepare阶段：给类变量默认赋值 ---->initial阶段：给类变量显示赋值，即静态代码块赋值
实例变量：随着对象的创建，在堆空间分配实例变量空间，并进行默认赋值
② 局部变量：在使用前， 必须进行显式赋值！否则，编译不通过
package com.lzx.JVMObject;
/**
* @author lzx
* @version 1.0
*/
public class VariableAndObject {
/**
* 基本实例变量，存在堆空间（值），属于通过VariableAndObject创建的实例对象，不一定线程不安全
*/
int baseInstanceVariable = 0;
/**
* 基本类变量，存在方法区，属于VariableAndObject类，一定线程不安全
*/
static int baseClassVariable = 0;
/**
* 引用实例变量，存在堆空间（引用和值），属于通过VariableAndObject创建的实例对象，不一定线程不安全
*/
Object referenceInstanceVariable = new Object();
/**
* 引用类变量，存在方法区（引用和值），属于VariableAndObject类，一定线程不安全
*/
static Object referenceClassVariable = new Object();
public void method() {
/**
* 基本局部变量，存在栈空间（值），属于method，一定线程安全
*/
int baseLocalVariable = 0;
/**
* 引用局部变量，引用存在栈空间，实例对象存在堆（逃逸的情况下），属于method，一定线程安全
*/
Object referenceLocalVariable = new Object();
}
}
class Object {
/**
* 基本实例变量，存在堆空间（值），属于通过Object创建的实例对象，不一定线程不安全
*/
int baseInstanceVariable = 0;
/**
* 基本类变量，存在方法区，属于Object类，一定线程不安全
*/
static int baseClassVariable = 0;
/**
* 引用实例变量，存在堆空间（引用和值），属于通过Object创建的实例对象，不一定线程不安全
*/
Object referenceInstanceVariable = new Object();
/**
* 引用类变量，存在方法区（引用和值），属于Object类，一定线程不安全
*/
static Object referenceClassVariable = new Object();
public void method() {
/**
* 基本局部变量，存在栈空间（值），属于method，一定线程安全
*/
int baseLocalVariable = 0;
/**
* 引用局部变量，引用存在栈空间，实例对象存在堆（逃逸的情况下），属于method，一定线程安全
*/
Object referenceLocalVariable = new Object();
}
}
- JVM中可以存储变量的有虚拟机栈，堆和方法区，而这其中只有虚拟机栈是线程独享的，代表虚拟机栈的变量是线程安全的
# 虚拟机栈存储的变量与线程安全
- 虚拟机栈存储没有发生逃逸的局部变量的指针和实例对象，而发生逃逸的局部变量的指针存在栈上，实例对象（值）存在堆上。由于局部变量是每个线程独享的，所以多个线程操作同一块代码的局部变量时，每个线程的变量是不一样的，所以局部变量是没有线程安全问题的
代码演示
package com.lzx.JVMObjectThreadSafe;
import java.util.ArrayList;
import java.util.List;
/**
* 局部变量线程安全测试,结果：局部变量一定线程安全
*
* @author lzx
* @version 1.0
*/
public class LocalVariableThreadSafe {
public static void main(String[] args) {
LocalVariableThreadSafeByRunnable localVariableThreadSafeByRunnable = new LocalVariableThreadSafeByRunnable();
for (int i = 0; i < 2; i++) {
LocalVariableThreadSafeByThread localVariableThreadSafeByThread = new LocalVariableThreadSafeByThread();
localVariableThreadSafeByThread.setName("资源不共享的线程" + i + "创建方式");
localVariableThreadSafeByThread.start();
Thread thread = new Thread(localVariableThreadSafeByRunnable);
thread.setName("资源共享的线程" + i + "创建方式");
thread.start();
}
}
}
/**
* 资源不共享的线程创建方式
*/
class LocalVariableThreadSafeByThread extends Thread {
@Override
public void run() {
baseLocalVariableThreadSafeTest();
referenceLocalVariableThreadSafeTest();
}
/**
* 基本局部变量线程安全测试
*/
public void baseLocalVariableThreadSafeTest() {
int num = 0;
for (int i = 1; i <= 10; i++) {
num += i;
}
System.out.println(Thread.currentThread().getName() + "(extends Thread)的引用局部变量:" + num);
}
/**
* 引用局部变量线程安全测试
*/
public void referenceLocalVariableThreadSafeTest() {
List list = new ArrayList<>();
for (int i = 1; i <= 10; i++) {
list.add(i);
}
System.out.println(Thread.currentThread().getName() + "(extends Thread)的引用局部变量:" + list.toString());
}
}
/**
* 资源共享的线程创建方式
*/
class LocalVariableThreadSafeByRunnable implements Runnable {
@Override
public void run() {
baseLocalVariableThreadSafeTest();
referenceLocalVariableThreadSafeTest();
}
/**
* 基本局部变量线程安全测试
*/
public void baseLocalVariableThreadSafeTest() {
int num = 0;
for (int i = 1; i <= 10; i++) {
num += i;
}
System.out.println(Thread.currentThread().getName() + "(implements Runnable)的基本局部变量:" + num);
}
/**
* 引用局部变量线程安全测试
*/
public void referenceLocalVariableThreadSafeTest() {
List list = new ArrayList<>();
for (int i = 1; i <= 10; i++) {
list.add(i);
}
System.out.println(Thread.currentThread().getName() + "(implements Runnable)的引用局部变量:" + list.toString());
}
# 堆存储的变量与线程安全
- 堆存储着实例变量（引用和实例对象），实例变量的线程安全问题需要分情况而定，如果该实例对象在共享的线程内（使用implements Runnable去创建的线程），那该实例对象是线程不安全的，如果该实例对象在不共享的线程内（使用extends Thread去创建的线程），那该实例对象是线程安全的，注意如果使用fianl修饰的实例变量是基本数据类型，那也可以保证线程安全
代码演示
package com.lzx.JVMObjectThreadSafe;
import java.util.ArrayList;
import java.util.List;
/**
* 实例变量线程安全测试,结果：该实例对象在共享的线程内（使用implements Runnable去创建的线程），那该实例对象是线程不安全的，
* 如果该实例对象在不共享的线程内（使用extends Thread去创建的线程），那该实例对象是线程安全的
*
* @author lzx
* @version 1.0
* @date 2020/9/14 15:40
*/
public class InstanceVariableThreadSafe {
public static void main(String[] args) {
InstanceVariableThreadSafeByRunnable instanceVariableThreadSafeByRunnable = new InstanceVariableThreadSafeByRunnable();
for (int i = 0; i < 100; i++) {
InstanceVariableThreadSafeByThread instanceVariableThreadSafeByThread = new InstanceVariableThreadSafeByThread();
instanceVariableThreadSafeByThread.setName("资源不共享的线程" + i + "创建方式");
instanceVariableThreadSafeByThread.start();
Thread thread = new Thread(instanceVariableThreadSafeByRunnable);
thread.setName("资源共享的线程" + i + "创建方式");
thread.start();
}
}
}
/**
* 资源不共享的线程创建方式
*/
class InstanceVariableThreadSafeByThread extends Thread {
int num = 0;
List list = new ArrayList<>();
@Override
public void run() {
baseInstanceVariableThreadSafeTest();
referenceInstanceVariableThreadSafeTest();
}
/**
* 基本实例变量线程安全测试
*/
public void baseInstanceVariableThreadSafeTest() {
for (int i = 1; i <= 10; i++) {
num += i;
}
System.out.println(Thread.currentThread().getName() + "(extends Thread)的引用实例变量:" + num);
}
/**
* 引用实例变量线程安全测试
*/
public void referenceInstanceVariableThreadSafeTest() {
for (int i = 1; i <= 10; i++) {
list.add(i);
}
System.out.println(Thread.currentThread().getName() + "(extends Thread)的引用实例变量:" + list.toString());
}
}
/**
* 资源共享的线程创建方式
*/
class InstanceVariableThreadSafeByRunnable implements Runnable {
int num = 0;
List list = new ArrayList<>();
@Override
public void run() {
baseInstanceVariableThreadSafeTest();
referenceInstanceVariableThreadSafeTest();
}
/**
* 基本实例变量线程安全测试
*/
public void baseInstanceVariableThreadSafeTest() {
for (int i = 1; i <= 10; i++) {
num += i;
}
System.out.println(Thread.currentThread().getName() + "(implements Runnable)的基本实例变量:" + num);
}
/**
* 引用实例变量线程安全测试
*/
public void referenceInstanceVariableThreadSafeTest() {
for (int i = 1; i <= 10; i++) {
list.add(i);
}
System.out.println(Thread.currentThread().getName() + "(implements Runnable)的引用实例变量:" + list.toString());
}
}
# 方法区存储的变量与线程安全
- 方法区（元空间）存储着类变量（即使用static修饰的成员变量，这部分的变量是属于类的，由所有线程共享，会有线程安全问题）和静态常量，（这部分的常量是指final修饰的类变量，同理如果使用fianl修饰的类变量是基本数据类型，那可以保证线程安全）
代码演示
package com.lzx.JVMObjectThreadSafe;
import java.util.ArrayList;
import java.util.List;
/**
* 类变量线程安全测试,结果：类变量是属于类的，在类创建的时候就已经存在，多个线程共享，所以类变量是线程不安全的
*
* @author lzx
* @version 1.0
* @date 2020/9/14 15:40
*/
public class ClassVariableThreadSafe {
public static void main(String[] args) {
ClassVariableThreadSafeByRunnable classVariableThreadSafeByRunnable = new ClassVariableThreadSafeByRunnable();
for (int i = 0; i < 100; i++) {
ClassVariableThreadSafeByThread classVariableThreadSafeByThread = new ClassVariableThreadSafeByThread();
classVariableThreadSafeByThread.setName("资源不共享的线程" + i + "创建方式");
classVariableThreadSafeByThread.start();
Thread thread = new Thread(classVariableThreadSafeByRunnable);
thread.setName("资源共享的线程" + i + "创建方式");
thread.start();
}
}
}
/**
* 资源不共享的线程创建方式
*/
class ClassVariableThreadSafeByThread extends Thread {
static int num = 0;
static List list = new ArrayList<>();
@Override
public void run() {
baseClassVariableThreadSafeTest();
referenceClassVariableThreadSafeTest();
}
/**
* 基本类变量线程安全测试
*/
public void baseClassVariableThreadSafeTest() {
for (int i = 1; i <= 10; i++) {
num += i;
}
System.out.println(Thread.currentThread().getName() + "(extends Thread)的引用类变量:" + num);
}
/**
* 引用类变量线程安全测试
*/
public void referenceClassVariableThreadSafeTest() {
for (int i = 1; i <= 10; i++) {
list.add(i);
}
System.out.println(Thread.currentThread().getName() + "(extends Thread)的引用类变量:" + list.toString());
}
}
/**
* 资源共享的线程创建方式
*/
class ClassVariableThreadSafeByRunnable implements Runnable {
static int num = 0;
static List list = new ArrayList<>();
@Override
public void run() {
baseClassVariableThreadSafeTest();
referenceClassVariableThreadSafeTest();
}
/**
* 基本类变量线程安全测试
*/
public void baseClassVariableThreadSafeTest() {
for (int i = 1; i <= 10; i++) {
num += i;
}
System.out.println(Thread.currentThread().getName() + "(implements Runnable)的基本类变量:" + num);
}
/**
* 引用类变量线程安全测试
*/
public void referenceClassVariableThreadSafeTest() {
for (int i = 1; i <= 10; i++) {
list.add(i);
}
System.out.println(Thread.currentThread().getName() + "(implements Runnable)的引用类变量:" + list.toString());
}
}
# final与线程安全
- 粗略的来讲final修饰的变量的都可以叫做常量，但是如果严格来讲，final修饰的变量是基本数据类型的时候可以叫做常量，而是引用类型的时候叫做不可变变量（引用恒定不变），注意，当使用final修饰实例变量或者类变量，如果这个数据类型是基本数据类型，那这个不管是在堆或者方法区都是线程安全的，但是如果这个数据类型是引用类型，那这个就不是线程安全的，因为使用final修饰基本数据类型时可以保证值不变，但是修饰引用类型时，只能保证其引用恒定不变（无法让其指向一个新的对象），但是实例对象的内容却可以被修改
例如
package com.lzx;
public class JVMObjectTest {
private final static StringBuilder finalStaticSB = new StringBuilder("a");
private final StringBuilder finalSB = new StringBuilder("a");
public static void main(String[] args) {
// finalStaticSB = new StringBuilder() //报错，无法指向新引用
finalStaticSB.append("b"); //正常，可以改变值
JVMObjectTest jvmObjectTest = new JVMObjectTest();
//jvmObjectTest.finalSB = new StringBuilder() //报错，无法指向新引用
jvmObjectTest.finalSB.append("b"); //正常，可以改变值
System.out.println(finalStaticSB);
System.out.println(jvmObjectTest.finalSB);
}
}
第三章JMM与线程安全
# 原子性
- 原子性指的是一个操作是不可中断的，即使是在多线程环境下，一个操作一旦开始就不会被其他线程影响。原子性问题，除了JVM自身提供的对基本数据类型读写操作的原子性外，对于方法级别或者代码块级别的原子性操作，可以使用synchronized关键字或者锁保证程序执行的原子性。
# 指令重排
- 计算机在执行程序时，为了提高性能，编译器和处理器的常常会对指令做重排，一般分以下3种
- 编译器优化的重排
- 编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。
- 指令并行的重排
- 现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性(即后一个执行的语句无需依赖前面执行的语句的结果)，处理器可以改变语句对应的机器指令的执行顺序
- 内存系统的重排
- 由于处理器使用缓存和读写缓存冲区，这使得加载(load)和存储(store)操作看上去可能是在乱序执行，因为三级缓存的存在，导致内存与缓存的数据同步存在时间差。
其中编译器优化的重排属于编译期重排，指令并行的重排和内存系统的重排属于处理器重排，在多线程环境中，这些重排优化可能会导致程序出现内存可见性问题。
# 可见性
- 理解了指令重排现象后，可见性容易了，可见性指的是当一个线程修改了某个共享变量的值，其他线程是否能够马上得知这个修改的值。对于串行程序来说，可见性是不存在的，因为我们在任何一个操作中修改了某个变量的值，后续的操作中都能读取这个变量值，并且是修改过的新值。但在多线程环境中可就不一定了，前面我们分析过，由于线程对共享变量的操作都是线程拷贝到各自的工作内存进行操作后才写回到主内存中的，这就可能存在一个线程A修改了共享变量x的值，还未写回主内存时，另外一个线程B又对主内存中同一个共享变量x进行操作，但此时A线程工作内存中共享变量x对线程B来说并不可见，这种工作内存与主内存同步延迟现象就造成了可见性问题，另外指令重排以及编译器优化也可能导致可见性问题，通过前面的分析，我们知道无论是编译器优化还是处理器优化的重排现象，在多线程环境下，确实会导致程序轮序执行的问题，从而也就导致可见性问题。
- 工作内存与主内存同步延迟现象导致的可见性问题，可以使用synchronized关键字或者volatile关键字解决，它们都可以使一个线程修改后的变量立即对其他线程可见。
# 有序性
- 有序性是指对于单线程的执行代码，我们总是认为代码的执行是按顺序依次执行的，这样的理解并没有毛病，毕竟对于单线程而言确实如此，但对于多线程环境，则可能出现乱序现象，因为程序编译成机器码指令后可能会出现指令重排现象，重排后的指令与原指令的顺序未必一致，要明白的是，在Java程序中，倘若在本线程内，所有操作都视为有序行为，如果是多线程环境下，一个线程中观察另外一个线程，所有操作都是无序的，前半句指的是单线程内保证串行语义执行的一致性，后半句则指指令重排现象和工作内存与主内存同步延迟现象。
- 指令重排导致的可见性问题和有序性问题，则可以利用volatile关键字解决，因为volatile的另外一个作用就是禁止重排序优化
# JMM中的happens-before 原则
- 除了靠sychronized和volatile关键字来保证原子性、可见性以及有序性外，JMM内部还定义一套happens-before 原则来保证多线程环境下两个操作间的原子性、可见性以及有序性。
- happens-before是JMM的核心，在Java内存模型中，提供了happens-before 原则来辅助保证程序执行的原子性、可见性以及有序性的问题，它是判断数据是否存在竞争、线程是否安全的依据，happens-before 原则内容如下
- 程序顺序原则，即在一个线程内必须保证语义串行性，也就是说按照代码顺序执行。
- 锁规则 解锁(unlock)操作必然发生在后续的同一个锁的加锁(lock)之前，也就是说，如果对于一个锁解锁后，再加锁，那么加锁的动作必须在解锁动作之后(同一个锁)。
- volatile规则 volatile变量的写，先发生于读，这保证了volatile变量的可见性，简单的理解就是，volatile变量在每次被线程访问时，都强迫从主内存中读该变量的值，而当该变量发生变化时，又会强迫将最新的值刷新到主内存，任何时刻，不同的线程总是能够看到该变量的最新值。
- 线程启动规则 线程的start()方法先于它的每一个动作，即如果线程A在执行线程B的start方法之前修改了共享变量的值，那么当线程B执行start方法时，线程A对共享变量的修改对线程B可见
- 传递性 A先于B ，B先于C 那么A必然先于C
- 线程终止规则 线程的所有操作先于线程的终结，Thread.join()方法的作用是等待当前执行的线程终止。假设在线程B终止之前，修改了共享变量，线程A从线程B的join方法成功返回后，线程B对共享变量的修改将对线程A可见。
- 线程中断规则 对线程 interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过Thread.interrupted()方法检测线程是否中断。
- 对象终结规则 对象的构造函数执行，结束先于finalize()方法
案例演示这8条原则如何判断线程是否安全：
class MixedOrder{
int a = 0;
boolean flag = false;
public void writer(){
a = 1;
flag = true;
}
public void read(){
if(flag){
int i = a + 1；
}
}
}
解析：存在两条线程A和B，线程A调用实例对象的writer()方法，而线程B调用实例对象的read()方法，线程A先启动而线程B后启动，那么线程B读取到的i值是多少呢？现在依据8条原则，由于存在两条线程同时调用，因此程序次序原则不合适。writer()方法和read()方法都没有使用同步手段，锁规则也不合适。没有使用volatile关键字，volatile变量原则不适应。线程启动规则、线程终止规则、线程中断规则、对象终结规则、传递性和本次测试案例也不合适。线程A和线程B的启动时间虽然有先后，但线程B执行结果却是不确定，也是说上述代码没有适合8条原则中的任意一条，也没有使用任何同步手段，所以上述的操作是线程不安全的，因此线程B读取的值自然也是不确定的。修复这个问题的方式很简单，要么给writer()方法和read()方法添加同步手段，如synchronized或者给变量flag添加volatile关键字，确保线程A修改的值对线程B总是可见。
# volatile内存语义
- volatile是Java虚拟机提供的轻量级的同步机制。volatile关键字有如下两个作用
- 保证被volatile修饰的共享变量对所有线程总数可见的，也就是当一个线程修改了一个被volatile修饰共享变量的值，新值总数可以被其他线程立即得知。
- volatile的另一个功能是：禁止指令重排序优化。
# volatile的可见性
关于volatile的可见性作用，我们必须意识到被volatile修饰的变量对所有线程总是立即可见的，对volatile变量的所有写操作总是能立刻反应到其他线程中，但是对于volatile变量运算操作在多线程环境并不保证安全性（不能保证原子性），原因是可能会有两个线程同时读到同一个数值，如下
package com.lzx.KeywordThreadSafe.Volatile;
/**
* Volatile不安全测试，结果：Volatile并不能保证原子性
* @author lzx
* @version 1.0
*/
public class VolatileVisibilityThreadUnSafe {
public static void main(String[] args) {
VolatileVisibilityByRunnable volatileVisibilityByRunnable = new VolatileVisibilityByRunnable();
for (int i = 0; i < 100; i++) {
Thread thread = new Thread(volatileVisibilityByRunnable);
thread.setName("资源共享的线程" + i + "创建方式");
thread.start();
}
}
}
/**
* 资源共享的线程创建方式
*/
class VolatileVisibilityByRunnable implements Runnable {
volatile static int num = 0;
@Override
public void run() {
volatileVisibilityThreadUnSafeTest();
}
/**
* volatile原子性线程不安全测试
*/
public void volatileVisibilityThreadUnSafeTest() {
for (int i = 1; i <= 10; i++) {
num += i;
}
System.out.println(Thread.currentThread().getName() + "(implements Runnable)的volatile变量:" + num);
}
}
解析: 虽然num变量的任何改变都会立马反应到其他线程中，如果有多条线程同时读到一个值，并对同一个值进行操作，就会出现线程安全问题，毕竟num += i;操作并不具备原子性，该操作是先读取值，然后写回一个新值，分两步完成，如果第二个线程在第一个线程读取旧值和写回新值期间读取i的域值，那么第二个线程就会与第一个线程一起看到同一个值，并执行相同值操作，这也就造成了线程安全失败，因此对于volatileVisibilityThreadSafeTest方法必须使用synchronized修饰，以便保证线程安全，需要注意的是一旦使用synchronized修饰方法后，由于synchronized本身也具备与volatile相同的特性，即可见性，因此在这样种情况下就完全可以省去volatile修饰变量。
另外一种场景，可以使用volatile修饰变量达到线程安全的目的，如下
package com.lzx.KeywordThreadSafe.Volatile;
/**
* Volatile安全测试，结果：Volatile可以保证可见性
* @author lzx
* @version 1.0
*/
public class VolatileVisibilityThreadSafe {
public static void main(String[] args) {
VolatileVisibilityByRunnable2 volatileVisibilityByRunnable2 = new VolatileVisibilityByRunnable2();
for (int i = 0; i < 10; i++) {
Thread thread = new Thread(volatileVisibilityByRunnable2);
thread.setName("资源共享的线程" + i + "创建方式");
thread.start();
}
}
}
/**
* 资源共享的线程创建方式
*/
class VolatileVisibilityByRunnable2 implements Runnable {
volatile static boolean close;
@Override
public void run() {
volatileVisibilityThreadSafeTest();
}
/**
* volatile可见性安全测试
*/
public void volatileVisibilityThreadSafeTest() {
close();
System.out.println(Thread.currentThread().getName() + "(implements Runnable)的volatile变量:" + close);
open();
System.out.println(Thread.currentThread().getName() + "(implements Runnable)的volatile变量:" + close);
}
public void close() {
close = true;
}
public void open() {
close = false;
}
}
解析：由于对于boolean变量close值的修改属于原子性操作，因此可以通过使用volatile修饰变量close，使用该变量对其他线程立即可见，从而达到线程安全的目的。那么JMM是如何实现让volatile变量对其他线程立即可见的呢？实际上，当写一个volatile变量时，JMM会把该线程对应的工作内存中的共享变量值刷新到主内存中，当读取一个volatile变量时，JMM会把该线程对应的工作内存置为无效，那么该线程将只能从主内存中重新读取共享变量。volatile变量正是通过这种写-读方式实现对其他线程可见。
# volatile禁止重排优化
- volatile关键字另一个作用就是禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象，关于指令重排优化前面已详细分析过，这里主要简单说明一下volatile是如何实现禁止指令重排优化的。先了解一个概念，内存屏障(Memory Barrier）。
内存屏障，又称内存栅栏，是一个CPU指令，它的作用有两个，一是保证特定操作的执行顺序，二是保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）。由于编译器和处理器都能执行指令重排优化。如果在指令间插入一条Memory Barrier则会告诉编译器和CPU，不管什么指令都不能和这条Memory Barrier指令重排序，也就是说通过插入内存屏障禁止在内存屏障前后的指令执行重排序优化。Memory Barrier的另外一个作用是强制刷出各种CPU的缓存数据，因此任何CPU上的线程都能读取到这些数据的最新版本。总之，volatile变量正是通过内存屏障实现其在内存中的语义，即可见性和禁止重排优化。下面看一个非常典型的禁止重排优化的例子，如下：
public class DoubleCheckLock {
private static DoubleCheckLock instance;
private DoubleCheckLock(){}
public static DoubleCheckLock getInstance(){
//第一次检测
if (instance==null){
//同步
synchronized (DoubleCheckLock.class){
if (instance == null){
//多线程环境下可能会出现问题的地方
instance = new DoubleCheckLock();
}
}
}
return instance;
}
}
上述代码一个经典的单例的双重检测的代码，这段代码在单线程环境下并没有什么问题，但如果在多线程环境下就可以出现线程安全问题。原因在于某一个线程执行到第一次检测，读取到的instance不为null时，instance的引用对象可能没有完成初始化。因为instance = new DoubleCheckLock();可以分为以下3步完成(伪代码)
memory = allocate(); //1.分配对象内存空间
instance(memory); //2.初始化对象
instance = memory; //3.设置instance指向刚分配的内存地址，此时instance！=null
由于步骤1和步骤2间可能会重排序，如下：
memory = allocate(); //1.分配对象内存空间
instance = memory; //3.设置instance指向刚分配的内存地址，此时instance！=null，但是对象还没有初始化完成！
instance(memory); //2.初始化对象
由于步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变，因此这种重排优化是允许的。但是指令重排只会保证串行语义的执行的一致性(单线程)，但并不会关心多线程间的语义一致性。所以当一条线程访问instance不为null时，由于instance实例未必已初始化完成，也就造成了线程安全问题。那么该如何解决呢，很简单，我们使用volatile禁止instance变量被执行指令重排优化即可。
//禁止指令重排优化
private volatile static DoubleCheckLock instance;