一、volatile是什么?
volatile是Java虚拟机提供的轻量级的同步机制。
二、volatile的三个特性?
- 保证可见性
- 不保证原子性
- 禁止指令重排
三、JMM与volatile
3.1 JMM介绍
JMM(Java内存模型Java Memory Model,简称JMM)本身是一种很抽象的概念,并不真实存在。它本身描述的是一组规则或规范,通过这组规范定义了程序中各个变量(包括实例变量,静态变量和构成数组对象的元素)的访问方式。
JMM关于同步的规定:
- 线程解锁前,必须把共享变量的值刷新回主内存。
- 线程加锁前,必须读取主内存的最新值到自己的工作内存。
- 加锁解锁是同一把锁。
由于JVM运行的实体是线程,而每个线程创建时JVM都会为其创建一个工作内存(有些地方称之为栈空间),工作内存是每个线程的私有数据区域。而Java内存模型规定所有变量都存储在主内存,主内存是共享内存区域,所有线程都可以访问。但线程对变量的操作(读取赋值等)必须在工作内存中进行,首先要将变量从主内存拷贝到自己的内存空间,然后对变量进行操作,操作完成后,再将变量写回主内存。不能直接操作主内存中的变量。各个线程的工作内存中存储着主内存中的变量副本拷贝,因此不同的线程间无法访问对方的工作内存,线程间的通信(传值)必须通过主内存来完成。
3.2 volatile保证可见性代码验证
3.2.1 不可见代码:
package com.yuxx.juc;
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() + " come in");
try{ TimeUnit.SECONDS.sleep(3); }catch (InterruptedException e){ e.printStackTrace(); }
myData.addTo60();
System.out.println(Thread.currentThread().getName() + " updated number value:"+myData.number);
},"AAA").start();
while(myData.number == 0){
//main线程一直在这里等待循环,直到number值不再等于0
}
System.out.println(Thread.currentThread().getName() + " mission is over");
}
}
class MyData{
int number = 0;//注意,此处没有任何其他修饰
public void addTo60(){
this.number = 60;
}
}
打印结果:
最后的“mission is over”没有打印,且程序没有结束,是因为线程AAA将number的值修改后,main线程并不知道number值已修改,还是原来的值0,导致main线程的while循环一直在等待。
3.2.2 volatile保证可见性代码
package com.yuxx.juc;
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() + " come in");
try{ TimeUnit.SECONDS.sleep(3); }catch (InterruptedException e){ e.printStackTrace(); }
myData.addTo60();
System.out.println(Thread.currentThread().getName() + " updated number value:"+myData.number);
},"AAA").start();
while(myData.number == 0){
//main线程一直在这里等待循环,直到number值不再等于0
}
System.out.println(Thread.currentThread().getName() + " mission is over");
}
}
class MyData{
volatile int number = 0;//此行有volatile修饰
public void addTo60(){
this.number = 60;
}
}
打印结果:
3.3 volatile不保证原子性代码验证
3.3.1 不保证原子性代码
package com.yuxx.juc;
class MyData{
volatile int number = 0;
public void addPlusPlus(){
number++;
}
}
/**
* 2 验证volatile 不保证原子性
* 2.1 原子性指的是什么意思?
* 不可分割,完整性,也即某个线程正在做某个具体业务时,中间不可以被加塞或者被分割,需要整体完整。要么同时成功,要么同时失败。
* 2.2 volatile不保证原子性的案例演示
* 2.3 why?
*/
public class VolatileDemo {
public static void main(String[] args) {
MyData myData = new MyData();
for(int i=0;i<20;i++){
new Thread(()->{
for(int j = 1;j<=1000;j++){
myData.addPlusPlus();
}
},String.valueOf(i)).start();
}
while(Thread.activeCount() > 2){
Thread.yield();
}
System.out.println(Thread.currentThread().getName() + " finally number value : " + myData.number);
}
}
打印结果:
原因:
i++操作在字节码文件中是分为三步:
_temp = i;
i = i + 1;
i = _temp;
可能出现的情况是,线程A和B同时拿到了执行权,A将i+1,B也将i+1,由于volatile不保证原子性,在A将i的值写回主存前的一瞬间,B已经将i+1后的值写回主存,此时A再将i+1的值返回主内存,就会覆盖掉之前B写回的内容,造成数据丢失。
3.3.2 解决volatile不保证原子性的办法
package com.yuxx.juc;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
class MyData{
//atomicInteger默认值为0
AtomicInteger atomicInteger = new AtomicInteger();
public void addMyAtomic(){
atomicInteger.getAndIncrement();
}
}
/**
* 2 验证volatile 不保证原子性
* 2.1 原子性指的是什么意思?
* 不可分割,完整性,也即某个线程正在做某个具体业务时,中间不可以被加塞或者被分割,需要整体完整。要么同时成功,要么同时失败。
* 2.2 volatile不保证原子性的案例演示
* 2.3 why?
* 2.4 如何解决
* * 加synchronized
* * 使用JUC下的AtomicInteger(底层是CAS算法)
*/
public class VolatileDemo {
public static void main(String[] args) {
MyData myData = new MyData();
for(int i=0;i<20;i++){
new Thread(()->{
for(int j = 1;j<=1000;j++){
myData.addMyAtomic();
}
},String.valueOf(i)).start();
}
while(Thread.activeCount() > 2){
Thread.yield();
}
System.out.println(Thread.currentThread().getName() + " AtomicInteger type,finally number value : " + myData.atomicInteger);
}
}
解决办法说明:将int类型,改为juc下的AtomicInteger,int i++ 改为 AtomicInteger.getAndIncrement(实例方法),AtomicXxx,底层实现是CAS算法。
3.4 volatile与指令重排
3.4.1 指令重排
计算机在执行程序时,为了提高性能,编译器和处理器常常会对指令做重排,一般分为以下三种:
单线程环境里确保程序最终执行结果与代码执行顺序的结果一致。
处理器在进行重排时必须要考虑指令之间的数据依赖性。
多线程环境中,线程交替执行,由于编译器优化重排的存在,两个线程中使用的变量能否保证一致性是无法确定的,结果无法预测。
3.4.2 指令重排演示
DEMO-1:
DEMO-2:
3.4.3 指令重排案例
public class ReSortSeqDemo {
int a = 0;
boolean flag = false;
public void method01(){
a = 1;//语句1
flag = true;//语句2
}
//多线程环境中线程交替执行,由于编译器优化重排的存在,两个线程中使用的变量能否保证一致性是无法确定的,结果无法预测
public void method02(){
if(flag){
a = a + 5;//语句3
System.out.println("retValue:" + a);
}
}
}
说明:
一般正常情况下,执行顺序是:语句1-语句2-语句3,最后执行结果是6。
但是由于编译器指令重排的客观存在,在多线程情况下,会导致这种情况:线程A在method01中,语句1和语句2顺序反过来了,先执行语句2,把flag变为true,还没有执行语句1,线程B进入method02方法,此时flag为true,a为0,a+5赋值给a,打印出来的a是5。
这就导致了指令重排后,造成数据的不一致。
3.4.4 volatile禁止指令重排
3.4.4.1 内存屏障
内存屏障(Memory Barrier)又称内存栅栏,是一个CPU指令,它的作用有两个:
- 保证特定操作的执行顺序
- 保证某些变量的内存可见性(利用该特性实现volatile的内存可见性)
由于编译器和处理器都能执行指令重排优化,如果在指令间插入一条Memory Barrier,则会告诉编译器和CPU,不管什么指令都不能和这条Memory Barrier 指令重排序。也就是说,通过内存屏障禁止在内存屏障前后的指令执行重排优化。
内存屏障的另一个作用是强制刷出各种CPU的缓存数据,因此任何CPU上的线程都能读到这些数据的最新版本。
对volatile变量进行写操作时,会在写操作后加入一条store屏障指令,将工作内存中的共享变量值刷回主内存。
对volatile变量进行读操作时,会在读操作前加入一条load屏障指令,从主内存中读取共享变量。
3.5 volatile的使用
3.5.1 单例模式DCL及在多线程下的问题
package com.yuxx.juc;
public class SingletonDemo {
private static SingletonDemo instance = null;
private SingletonDemo(){
System.out.println(Thread.currentThread().getName() + "\t 我是构造方法SingletonDemo()");
}
//DCL(Double Check Lock 双端检锁机制)
public static SingletonDemo getInstance() {
if(instance == null){
synchronized (SingletonDemo.class){
if(instance == null){
instance = new SingletonDemo();
}
}
}
return instance;
}
public static void main(String[] args) {
for (int i = 1; i <= 10 ; i++) {
new Thread(() -> {
SingletonDemo.getInstance();
},String.valueOf(i)).start();
}
}
}
DCL(双端检锁)机制并不一定安全,原因是指令重排序的存在。
原因在于,在某个线程执行到第一次检测,读取到的instance不为null时,instance的引用对象可能已经开始初始化但是还没有初始化完成。
instance = new SingletonDemo();可以分为以下3步完成(伪代码): >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.初始化对象 |
但是指令重排只会保证串行语义的执行的一致性(单线程),并不会关注多线程间的语义一致性。
所以当一条线程访问instance 不为 null 时,由于instance 实例未必初始化完成,也就造成了线程安全问题。
3.5.2 volatile解决单例模式DCL多线程不安全问题
package com.yuxx.juc;
public class SingletonDemo {
private static volatile SingletonDemo instance = null;
private SingletonDemo(){
System.out.println(Thread.currentThread().getName() + "\t 我是构造方法SingletonDemo()");
}
//DCL(Double Check Lock 双端检锁机制)
public static SingletonDemo getInstance() {
if(instance == null){
synchronized (SingletonDemo.class){
if(instance == null){
instance = new SingletonDemo();
}
}
}
return instance;
}
public static void main(String[] args) {
for (int i = 1; i <= 10 ; i++) {
new Thread(() -> {
SingletonDemo.getInstance();
},String.valueOf(i)).start();
}
}
}