死磕juc（五）volatile与Java内存模型

您所在的位置：网站首页 › volatile内存模型 › 死磕juc（五）volatile与Java内存模型

死磕juc（五）volatile与Java内存模型

#死磕juc（五）volatile与Java内存模型| 来源: 网络整理| 查看: 265

volatile与Java内存模型

一、被volatile修改的变量有2大特点1.1 特点可见性有序性1.2 volatile的内存语义当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值立即刷新回主内存中。当读一个volatile变量时，JMM会把该线程对应的本地内存设置为无效，直接从主内存中读取共享变量所以volatile的写内存语义是直接刷新到主内存中，读的内存语义是直接从主内存中读取。二、内存屏障2.1 是什么

内存屏障（也称内存栅栏，内存栅障，屏障指令等，是一类同步屏障指令，是CPU或编译器在对内存随机访问的操作中的一个同步点，使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作），避免代码重排序。内存屏障其实就是一种JVM指令，Java内存模型的重排规则会要求Java编译器在生成JVM指令时插入特定的内存屏障指令，通过这些内存屏障指令，volatile实现了Java内存模型中的可见性和有序性，但volatile无法保证原子性。

内存屏障之前的所有写操作都要回写到主内存，内存屏障之后的所有读操作都能获得内存屏障之前的所有写操作的最新结果(实现了可见性)。

因此重排序时，不允许把内存屏障之后的指令重排序到内存屏障之前。

一句话：对一个 volatile 域的写, happens-before 于任意后续对这个 volatile 域的读，也叫写后读。

2.2 volatile凭什么可以保证可见性和有序性？

内存屏障 (Memory Barriers / Fences)

2.3 JVM中提供了四类内存屏障指令2.3.1 C++源码分析

IDEA工具里面找Unsafe.class

Unsafe.java

Unsafe.cpp

OrderAccess.hpp

orderAccess_linux_x86.inline.hpp

2.3.2 四大屏障分别是什么意思

2.3.3 happens-before 之 volatile 变量规则

当第一个操作为volatile读时，不论第二个操作是什么，都不能重排序。这个操作保证了volatile读之后的操作不会被重排到volatile读之前。

当第二个操作为volatile写时，不论第一个操作是什么，都不能重排序。这个操作保证了volatile写之前的操作不会被重排到volatile写之后。

当第一个操作为volatile写时，第二个操作为volatile读时，不能重排。

2.3.4 JMM 就将内存屏障插⼊策略分为 4 种

写

在每个 volatile 写操作的前⾯插⼊⼀个 StoreStore 屏障在每个 volatile 写操作的后⾯插⼊⼀个 StoreLoad 屏障

读

在每个 volatile 读操作的后⾯插⼊⼀个 LoadLoad 屏障在每个 volatile 读操作的后⾯插⼊⼀个 LoadStore 屏障

三、volatile特性3.1 保证可见性3.1.1 说明

保证不同线程对这个变量进行操作时的可见性，即变量一旦改变所有线程立即可见

3.1.2 Codepublic class VolatileSeeDemo { static boolean flag = true; //不加volatile，没有可见性 //static volatile boolean flag = true; //加了volatile，保证可见性 public static void main(String[] args) { new Thread(() -> { System.out.println(Thread.currentThread().getName()+"\t come in"); while (flag) { } System.out.println(Thread.currentThread().getName()+"\t flag被修改为false,退出....."); },"t1").start(); //暂停2秒钟后让main线程修改flag值 try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } flag = false; System.out.println("main线程修改完成"); } }

不加volatile，没有可见性，程序无法停止

加了volatile，保证可见性，程序可以停止

3.1.3 上述代码原理解释

线程t1中为何看不到被主线程main修改为false的flag的值？

问题可能:

主线程修改了flag之后没有将其刷新到主内存，所以t1线程看不到。主线程将flag刷新到了主内存，但是t1一直读取的是自己工作内存中flag的值，没有去主内存中更新获取flag最新的值。

我们的诉求： 1.线程中修改了工作内存中的副本之后，立即将其刷新到主内存； 2.工作内存中每次读取共享变量时，都去主内存中重新读取，然后拷贝到工作内存。

解决：使用volatile修饰共享变量，就可以达到上面的效果，被volatile修改的变量有以下特点：

线程中读取的时候，每次读取都会去主内存中读取共享变量最新的值，然后将其复制到工作内存线程中修改了工作内存中变量的副本，修改之后会立即刷新到主内存3.1.4 volatile变量的读写过程

Java内存模型中定义的8种工作内存与主内存之间的原子操作

read(读取)→load(加载)→use(使用)→assign(赋值)→store(存储)→write(写入)→lock(锁定)→unlock(解锁)

read: 作用于主内存，将变量的值从主内存传输到工作内存，主内存到工作内存

load: 作用于工作内存，将read从主内存传输的变量值放入工作内存变量副本中，即数据加载

use: 作用于工作内存，将工作内存变量副本的值传递给执行引擎，每当JVM遇到需要该变量的字节码指令时会执行该操作

assign: 作用于工作内存，将从执行引擎接收到的值赋值给工作内存变量，每当JVM遇到一个给变量赋值字节码指令时会执行该操作

store: 作用于工作内存，将赋值完毕的工作变量的值写回给主内存

write: 作用于主内存，将store传输过来的变量值赋值给主内存中的变量

由于上述只能保证单条指令的原子性，针对多条指令的组合性原子保证，没有大面积加锁，所以，JVM提供了另外两个原子指令：

lock: 作用于主内存，将一个变量标记为一个线程独占的状态，只是写时候加锁，就只是锁了写变量的过程。

unlock: 作用于主内存，把一个处于锁定状态的变量释放，然后才能被其他线程占用

3.2 没有原子性3.2.1 volatile变量的复合操作(如i++)不具有原子性class MyNumber { volatile int number = 0; public void addPlusPlus() { number++; } } public class VolatileNoAtomicDemo { public static void main(String[] args) throws InterruptedException { MyNumber myNumber = new MyNumber(); for (int i = 1; i { for (int j = 1; j 重排序OK 。

重排前

重排后

int a = 1; //1 int b = 20; //2 int c = a + b; //3

int b = 20; //1int a = 1; //2 int c = a + b; //3

结论：编译器调整了语句的顺序，但是不影响程序的最终结果。

重排序OK

存在数据依赖关系，禁止重排序 ===> 重排序发生，会导致程序运行结果不同。

编译器和处理器在重排序时，会遵守数据依赖性，不会改变存在依赖关系的两个操作的执行,但不同处理器和不同线程之间的数据性不会被编译器和处理器考虑，其只会作用于单处理器和单线程环境，下面三种情况，只要重排序两个操作的执行顺序，程序的执行结果就会被改变。

3.3.2 volatile的底层实现是通过内存屏障

volatile有关的禁止指令重排的行为

当第一个操作为volatile读时，不论第二个操作是什么，都不能重排序。这个操作保证了volatile读之后的操作不会被重排到volatile读之前。当第二个操作为volatile写时，不论第一个操作是什么，都不能重排序。这个操作保证了volatile写之前的操作不会被重排到volatile写之后。当第一个操作为volatile写时，第二个操作为volatile读时，不能重排。

四大屏障的插入情况

在每一个volatile写操作前面插入一个StoreStore屏障 StoreStore屏障可以保证在volatile写之前，其前面的所有普通写操作都已经刷新到主内存中。在每一个volatile写操作后面插入一个StoreLoad屏障 StoreLoad屏障的作用是避免volatile写与后面可能有的volatile读/写操作重排序在每一个volatile读操作后面插入一个LoadLoad屏障 LoadLoad屏障用来禁止处理器把上面的volatile读与下面的普通读重排序。在每一个volatile读操作后面插入一个LoadStore屏障 LoadStore屏障用来禁止处理器把上面的volatile读与下面的普通写重排序。

Code说明

//模拟一个单线程，什么顺序读？什么顺序写？ public class VolatileTest { int i = 0; volatile boolean flag = false; public void write(){ i = 2; flag = true; } public void read(){ if(flag){ System.out.println("---i = " + i); } } }

四、如何正确使用volatile4.1 单一赋值可以，but含复合运算赋值不可以(i++之类)volatile int a = 10volatile boolean flag = false4.2 状态标志，判断业务是否结束/** * 使用：作为一个布尔状态标志，用于指示发生了一个重要的一次性事件，例如完成初始化或任务结束 * 理由：状态标志并不依赖于程序内任何其他状态，且通常只有一种状态转换 * 例子：判断业务是否结束 */ public class UseVolatileDemo { private volatile static boolean flag = true; public static void main(String[] args) { new Thread(() -> { while(flag) { //do something...... } },"t1").start(); //暂停几秒钟线程 try { TimeUnit.SECONDS.sleep(2L); } catch (InterruptedException e) { e.printStackTrace(); } new Thread(() -> { flag = false; },"t2").start(); } }4.3 开销较低的读，写锁策略public class UseVolatileDemo { /** * 使用：当读远多于写，结合使用内部锁和 volatile 变量来减少同步的开销 * 理由：利用volatile保证读取操作的可见性；利用synchronized保证复合操作的原子性 */ public class Counter { private volatile int value; public int getValue() { return value; //利用volatile保证读取操作的可见性 } public synchronized int increment() { return value++; //利用synchronized保证复合操作的原子性 } } }4.4 DCL双端锁的发布4.4.1 问题

单线程看问题代码

public class SafeDoubleCheckSingleton { private static SafeDoubleCheckSingleton singleton; //私有化构造方法 private SafeDoubleCheckSingleton(){ } //双重锁设计 public static SafeDoubleCheckSingleton getInstance(){ if (singleton == null){ //1.多线程并发创建对象时，会通过加锁保证只有一个线程能创建对象 synchronized (SafeDoubleCheckSingleton.class){ if (singleton == null){ //隐患：多线程环境下，由于重排序，该对象可能还未完成初始化就被其他线程读取 singleton = new SafeDoubleCheckSingleton(); } } } //2.对象创建完毕，执行getInstance()将不需要获取锁，直接返回创建对象 return singleton; } }

单线程看问题代码

单线程环境下(或者说正常情况下)，在"问题代码处"，会执行如下操作，保证能获取到已完成初始化的实例

由于存在指令重排序…

多线程看问题代码

隐患：多线程环境下，在"问题代码处"，会执行如下操作，由于重排序导致2,3乱序，后果就是其他线程得到的是null而不是完成初始化的对象

right

problem

4.4.2 解决01

加volatile修饰

public class SafeDoubleCheckSingleton { //通过volatile声明，实现线程安全的延迟初始化。 private volatile static SafeDoubleCheckSingleton singleton; //私有化构造方法 private SafeDoubleCheckSingleton(){ } //双重锁设计 public static SafeDoubleCheckSingleton getInstance(){ if (singleton == null){ //1.多线程并发创建对象时，会通过加锁保证只有一个线程能创建对象 synchronized (SafeDoubleCheckSingleton.class){ if (singleton == null){ //隐患：多线程环境下，由于重排序，该对象可能还未完成初始化就被其他线程读取 //原理:利用volatile，禁止 "初始化对象"(2) 和 "设置singleton指向内存空间"(3) 的重排序 singleton = new SafeDoubleCheckSingleton(); } } } //2.对象创建完毕，执行getInstance()将不需要获取锁，直接返回创建对象 return singleton; } }4.4.3 解决02

采用静态内部类的方式实现

//现在比较好的做法就是采用静态内部内的方式实现 public class SingletonDemo { private SingletonDemo() { } private static class SingletonDemoHandler { private static SingletonDemo instance = new SingletonDemo(); } public static SingletonDemo getInstance() { return SingletonDemoHandler.instance; } }五、最后的小总结5.1 内存屏障是什么