java关键字之volatile

港控/mmm° 2022-11-20 09:38 243阅读 0赞

### java关键字之volatile ###

*   *  前言
     *  volatile关键字的作用
     *  适用场景
     *  保证内存的可见性
     *   *  基本概念
         *  实现原理
     *  禁止指令重排
     *   *  基本概念
         *  指令重排带来的问题
         *  禁止指令重排的原理
         *  指令重排在双重锁定单例模式中的影响
     *  volatile和synchronized的区别

> 学习Java的同学注意了！！！  
> 学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：543120397 我们一起学Java！

## 前言 ##

> java语言是支持多线程的，为了解决线程并发的问题，在语言内部引入了synchronized和volatile关键字

## volatile关键字的作用 ##

> volatile保证了变量内存可见性。  
> volatile禁止JVM指令重排。

## 适用场景 ##

> (1)volatile是轻量级的同步机制。在访问volatile变量时，不会执行加锁操作，因此也不会造成线程阻塞(BLOCK)，它是一种比synchronized更轻量级的同步机制。

> (2)volatile无法同时保证内存的可见性和原子性。加锁机制，既可以保证可见性，又可以保证原子性，而volatile只能确保原子性。

> (3)volatile不能修饰写入操作依赖当前值的变量。申明为volatile变量如果当前值与变量以前的值相关，那么volatile关键字不起作用，也就是说如下的表达式都不是原子操作：  
> count++、count = count + 1;

> (4)当要访问的变量已在synchronized代码块中，没必要使用volatile。

> (5)volatile屏蔽了JVM中必要的代码优化，所以在执行效率上较低，因此在必要时，再使用该关键字。

## 保证内存的可见性 ##

### 基本概念 ###

> 可见性是指线程之间的可见性，一个线程修改的状态对于另外一个线程是可见的。也就是一个线程修改的结果，另一个线程马上就能看到。

### 实现原理 ###

> 当对非volatile变量进行读写操作的时候，每个线程先从主内存拷贝变量到CPU缓存中，如果计算机有多个CPU，每个线程可能在不同的CPU上被处理，这意味着每个线程可以拷贝变量到不同的CPU cache中。

> volatile变量不会被缓存在寄存器或者其他处理器不可见的地方，保证了每次读写变量都是从主内存中读，跳过CPU cache这一步。当一个线程修改了这个变量的值，新值对于其他线程是立即得知的。

## 禁止指令重排 ##

### 基本概念 ###

> 指令重排序是JVM为了优化指令、提高程序运行效率，在不影响单线程程序执行结果的情况下，尽可能地提高并行度。指令重排序包括编译器重排序和运行时重排序。

> volatile禁止指令重排序，针对volatile修饰的变量，在读写操作指令前后，会插入内存屏障，指令重排序时，不能把后面的指令重排序到内存屏障。

> 示例：  
> double r = 2; (1)  
> double pi = 3.14; (2)  
> double area = pi \* r \* r; (3)

> 虽然代码语句的顺序是 (1) -> (2) -> (3)，但计算时 (1) -> (2) -> (3)和(2) -> (1) -> (3) 对结果并无影响，所以编译时和运行时，可以根据需要对1、2语句进行重排序。

### 指令重排带来的问题 ###

> 如果一个操作不是原子的，就会给JVM留下重排序的机会。

线程A中
    { 
    	context = loadContext();
    	inited = true;
    }
    
    线程B中
    { 
    	if(inited){ 
    		fun(context)
    	}
    }

> 如果线程A中的指令发生重排序，那么很可能线程B中，会因为context尚未初始化或者尚未初始化完成，而发生程序错误。因为线程A中指令不是原子性的。

### 禁止指令重排的原理 ###

> volatile关键字提供内存屏障的方式防止指令被重排，编译器在生成字节码文件时，会在指令序列中，插入内存屏障来禁止特定类型的处理器重排序。

### 指令重排在双重锁定单例模式中的影响 ###

> 基于双重检测的单例模式(懒汉型)

public class Singleton{ 
    	private static Singleton instance = null;
    
    	private Singleton(){ }
    
    	public static Singleton getInstance(){ 
    		if(instance == null){ 
    			synchronized(Singleton.class){ 
    				if(instance == null){ 
    					//非原子操作
    					instance = new Singleton();
    				}
    			}
    		}
    		return instance;
    	}
    }

> instance = new Singleton();并不是一个原子操作，它可以拆分成下面几条JVM指令  
> memory = allocate; //1.分配对象的内存空间  
> initInstance(memory); //2.初始化对象  
> instance = memory; //3.设置instance指向刚分配的内存地址

> 上面第2步操作依赖于第1步操作，而第3步操作，并不依赖于第2步操作。所以JVM是可以进行指令重排序的，经过重排序后如下：  
> memory = allocate; //1.分配对象的内存空间  
> instance = memory; //2.设置instance指向刚分配的内存地址，可是还没有初始化  
> initInstance(memory); //3.初始化对象

> 指令重排之后，instance指向分配好的内存放在前面，而这段内存的初始化被排到了后面。线程A执行 instance = memory，这段赋值语句，在初始化分配对象之前，就已经将其赋值给instance引用。如果此时另外一个线程刚好进入判断，此时instance引用不为null，直接返回使用，导致出错。

**解决办法**

> 用volatile修饰instance变量，使得instance在读、写操作之前都会插入内存屏障，防止被重排序。

public class Singleton{ 
    	private static volatile Singleton instance = null;
    
    	private Singleton(){ }
    
    	public static Singleton getInstance(){ 
    		if(instance == null){ 
    			synchronized(Singleton.class){ 
    				if(instance == null){ 
    					//非原子操作
    					instance = new Singleton();
    				}
    			}
    		}
    		return instance;
    	}
    }

## volatile和synchronized的区别 ##

<table> 
 <thead> 
  <tr> 
   <th>切入点</th> 
   <th>volatile</th> 
   <th>synchronized</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>使用上</td> 
   <td>只能修饰变量</td> 
   <td>可以修饰变量、方法</td> 
  </tr> 
  <tr> 
   <td>内存模型上</td> 
   <td>只能保证可见性</td> 
   <td>可以保证可见性、原子性</td> 
  </tr> 
  <tr> 
   <td>是否造成线程阻塞</td> 
   <td>不会</td> 
   <td>可能会</td> 
  </tr> 
  <tr> 
   <td>能够被编译器优化</td> 
   <td>不会</td> 
   <td>可能会</td> 
  </tr> 
 </tbody> 
</table>