volatile详解-软件工程课程教学网

返回
顶部

修改密码

* 旧密码：

* 新密码：

* 确认新密码：

首页 > 知识摘要 > Java专题 > 正文

volatile详解

2023-09-18 15:42:26

来源：本站编辑

阅读量：

这个操作保证了volatile写之前的操作不会被重排到volatile写之后 **(volatile写之前的操作内存屏障之后的所有读操作都能获得内存屏障之前的所有写操作的最新结果(实现了可见性)避免volatile写与后面可能有的volatile读/写操作重排序这个操作保证了volatile读之后的操作不会被重排到volatile读之前**（volatile读之后的操作保证store 1的写操作已刷新到主内存** 保证store1的写操作已刷新到主内存之后**内存屏障之前的所有写操作都要回写

一. volatile的内存语义
----------------

当写一个volatile变量时，[JMM](https://so.csdn.net/so/search?q=JMM&spm=1001.2101.3001.7020)会把该线程对应的本地内存中的共享变量值立即刷新回主内存中

当读一个volatile变量时，JMM会把该线程对应的本地内存设置为无效，直接从主内存中读取共享变量

**所以volatile的写内存语义是直接刷新到主内存中，读的内存语义是直接从主内存中读取**

**二.  volatile变量的读写过程**
-----------------------

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

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

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

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

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

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

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

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

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

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

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

![](/u/cms/www/202304/02082328u1ki.png)

三. 内存屏障
-------

### 1\. volatile凭什么可以保证可见性和有序性？

**内存屏障**

### **2\. 什么是内存屏障**

内存屏障(也称内存栅栏，内存栅障，屏障指令等，是一类同步屏障指令，**是CPU或编译器在对内存随机访问的操作中的一个同步点，使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作)**，避免代码重排序。

内存屏障其实就是一种JVM指令，**Java内存模型的重排规则会要求Java编译器在生成JVM指令时插入特定的内存屏障指令**，通过这些内存屏障指令，volatile实现了[Java内存模型](https://so.csdn.net/so/search?q=Java%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B&spm=1001.2101.3001.7020)中的可见性和有序性，但volatile无法保证原子性。**内存屏障之前的所有写操作都要回写到主内存，内存屏障之后的所有读操作都能获得内存屏障之前的所有写操作的最新结果(实现了可见性)。** 因此重排序时，不允许把内存屏障之后的指令重排序到内存屏障之前。

### **3\. 作用**

**1.阻止屏障两边的指令重排序**

**2.写数据时加入屏障，强制将线程私有工作内存的数据刷回主物理内存**

**3.读数据时加入屏障，线程私有工作内存的数据失效，重新到主物理内存中获取最新数据**

### **4\. 内存屏障四大指令**

内存屏障，其实也就是4条CPU的屏障指令
![](/u/cms/www/202304/02082443ohff.png)

**loadload()：**保证load1的读取操作在load2及后续读取操作之前执行。保证load2在读取的时候，自己缓存内到相应数据失效，load2会去主内存中获取最新的数据

**storestore()：**在store2及其后的写操作执行前，保证store 1的写操作已刷新到主内存

**loadstore()：**在store2及其后的写操作执行前，保证load1的读操作已读取结束

**storeload( ):** 保证store1的写操作已刷新到主内存之后，load2及其后的读操作才能执行。同时保证:强制把写缓冲区的数据刷回到主内存中，让工作内存/CPU高速缓存当中缓存的数据失效，重新到主内存中获取新的数据

### **5.  volatile关键字系统底层如何加入内存屏障**

volatile关键字影响的是Class 内的Field 的flags :添加了一个**ACC\_ \_VOLATILE**，JVM在把字节码生成为机器码的时候，发现操作是volatile 的变量的话，就会根据JMM要求，在相应的位置去插入内存屏障指令

四. volatile的三大特性
----------------

### 1\. 可见性

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

**使用volatile修饰共享变量，被volatile修改的变量有以下特点:  
        1.线程中读取的时候，每次读取都会去主内存中读取共享变量最新的值，然后将其复制到工作内存  
        2.线程中修改了工作内存中变量的副本，修改之后会立即刷新到主内存**

**从volatile变量的读写过程分析**

**要use(使用)一个变量的时候必需load(载入)，要载入的时候必需从主内存read(读取)这样就解决了读的可见性。****写操作是把assign和store做了关联(在assign(赋值)后必需store(存储))，store(存储)后write(写入)。 也就是做到了给一个变量赋值的时候一串关联指令直接把变量值写到主内存。 就这样通过用的时候直接从主内存取，在赋值到直接写回主内存做到了内存可见性**

```java
    public 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() + " come in");
				while (flag) {                
					new Integer(308);            
					}            
				System.out.println("t1 over");       
				, "t1").start();        
			try {            
				TimeUnit.SECONDS.sleep(1);       
			} catch (InterruptedException e) {
				e.printStackTrace();        
			}         
			new Thread(() -> { 
				flag = false;
			}, "t2").start();   
		}
	}
```

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

![](https://img-blog.csdnimg.cn/858be95eb77746a58017ff4ae8232762.png)

加volatile,保证可见性，线程停止

![](https://img-blog.csdnimg.cn/893199ede6184c96b107682e45be016f.png)

###  2. 无原子性

**原子性指的是一个操作是不可中断的，即使是在多线程环境下，一个操作一旦开始就不会被其他线程影响。**

![](/u/cms/www/202304/02083610nysl.png)

多线程环境下，"数据计算"和"数据赋值"操作可能多次出现，即操作非原子。若数据在加载之后，若主内存count变量发生修改之后，由于线程工作内存中的值在此前已经加载，从而不会对变更操作做出相应变化，即私有内存和公共内存中变量不同步，进而导致数据不一致。  
        **对于volatile变量，JVM只是保证从主内存加载到线程工作内存的值是最新的，也就是数据加载时是最新的。由此可见volatile解决的是变量读时的可见性问题，但无法保证原子性，对于多线程修改共享变量的场景必须使用加锁同步。**

以i++为例，不具备原子性，该操作是先读取值，然后写回一个新值，相当于原来的值加上1,  
分3步完成。**如果第二个线程在第一个线程读取旧值和写回新值期间（上图所指三步期间）读取i的域值，**那么第二个线程就会与第一个线程一起看到同一个值，并执行相同值的加1操作，这也就造成了线程安全失败，因此对于add方法必须使用synchronized修饰，以便保证线程安全。

**从volatile变量的读写过程分析**

**read-load-use和assign-store-write成为了两个不可分割的原子操作，但是在use和assign之间依然有极小的一段真空期，有可能变量会被其他线程读取，导致写丢失一次**

### 
![](/u/cms/www/202304/02083734z5vg.png)
如下列代码所示：volatile修饰的number几乎不可能加到10000，就是因为存在极小段真空期，被其他线程读取，导致写丢失一次

```java
   public class VolatileNoAtmicDemo {    
	   public static void main(String[] args) throws InterruptedException {
		   MyNumber myNumber = new MyNumber();
		   for (int i = 1; i <= 10; i++) {
			   new Thread(() -> {
				   for (int j = 1; j <= 1000; j++) {
					   myNumber.addPlusPlus();
				   }
			   }, String.valueOf(i)).start();
		   }
		   TimeUnit.SECONDS.sleep(1);
		   System.out.println(Thread.currentThread().getName() + "\t" + myNumber.number);
	   }
	}
	   
	class MyNumber {
		volatile int number = 0;
		public void addPlusPlus() {
			number++;
		}
	}
```

### 
3\. 指令禁重排

**重排序：**

**是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段，有时候会改变程序语句的先后顺序。不存在数据依赖关系，可以重排序; 存在数据依赖关系，禁止重排序** 。**但重排后的指令绝对不能改变原有的串行语义。**

**数据依赖性:**若两个操作访问同一变量，且这两个操作中有一个为写操作，此时两操作间就存在数据依赖性

**重排序的分类和执行流程 :**

**1.编译器优化的重排序:**编译器在不改变单线程串行语义的前提下，可以重新调整指令的执行顺序

**2.指令级并行的重排序:**处理器使用指令级并行技术来将多条指令重叠执行，若不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序

**3.内存系统的重排序:**由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是乱序执行

![](https://img-blog.csdnimg.cn/f674fb513f2740f8bfca81ed22093230.png)

**volatile有关禁重排的行为：**

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

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

3\. 当第一个操作为volatile写时，第二个操作为volatile读时，不能重排。**(volatile写之后volatile读，禁止重排序的)**

**内存屏障四大指令插入情况**

1.在每个volatile**写操作的前面插入一个StoreStore屏障**，保证在volatile写之前，其前面的所有普通写操作都已经刷新到主内存中。

2.在每个volatile**写操作的后面插入一个StoreLoad屏障**，避免volatile写与后面可能有的volatile读/写操作重排序

![](https://img-blog.csdnimg.cn/dcaf8d21f2f0483a95bdde94369670ce.png)

3.在每个volatile**读操作的后面插入一个LoadLoad屏障**，禁止处理器把上面的volatile读与下面的普通读重排序。

4.在每个volatile**读操作的后面插入一个LoadStore屏障**，禁止处理器把上面的volatile读与下面的普通写重排序。

![](https://img-blog.csdnimg.cn/226a9a5dc0474dbfb576b30378bf9603.png)  
五. 如何正确使用volatile
-----------------------------------------------------------------------------------------

由于volatile变量只能保证可见性，在不符合以下两条规则的运算场景中，我们仍然要通过加锁(使用synchronized、java.util.concurrent中 的锁或原子类)来保证原子性:  
        **运算结果并不依赖变量的当前值，或者能够确保只有单一的线程修改变量的值。  
        变量不需要与其他的状态变量共同参与不变约束。**

**1\. 单一赋值可以，但是含复合运算赋值不可以(i++之类)**

**volatile int a = 10;**

**2\. 状态标志，判断业务是否结束**

**使用:作为一个布尔状态标志，用于指示发生了一个重要的一次性事件，例如完成初始化或任务结束**

**理由:状态标志并不依赖于程序内任何其他状态，且通常只有一种状态转换**

**例子:判断业务是否结束 volatile boolean flag = false**

**3. 开销较低的读，写锁策略**

**使用:当读远多于写，结合使用内部锁和volatile变量来成少同步的开销**

**理由:利用volatile保证读取操作的可见性;利用synchronized保证复合操作的原子性)**

//当读远多于写，结合使用内部锁和volatile变量来成少同步的开销    public class Counter{        private volatile int value;        public int getValue(){            return value; //利用volatile保证读取操作的可见性        }        public synchronized int increment(){            return value++; //利用synchronized保证复合操作的原子性        }    }

**4. DCL双端锁的发布**

隐患: 多线程环境下，由于重排序，该对象可能还未完成初始化就被其他线程读取

```java
 class SafeDoubleCheckSingleton{
	 private static SafeDoubleCheckSingleton singleton;    
	 //私有化构造方法    
	 private SafeDoubleCheckSingleton(){}
	 //双锁设计
	 public static SafeDoubleCheckSingleton getSingleton(){
		 if(singleton == null){
			 //1.多线程并非创建对象时，会通过加锁保证只有一个线程能创建对象
			 synchronized (SafeDoubleCheckSingleton.class){
				 if(singleton == null){
					 singleton = new SafeDoubleCheckSingleton();
				 }
			 }
		 }
		 //2.对象创建完毕后，执行getInstance()将不需要获取锁，直接返回创建对象
		 return singleton;
	 }
 }
```

**修正方法1：加volatile（也即正确的DCL双端锁）**

**原理:利用volatile, 禁止止"初始化对象"(2)和"和设置singleton指向内存空间"(3)的重排序**

//通过volatile声明，实现线程安全的延迟初始化    private volatile static SafeDoubleCheckSingleton singleton;

**修正方法2：静态内部类**

```java
//静态内部类
class SingletonDemo{
	private SingletonDemo(){
	}    
	//私有的静态内部类，独有一份
	private static class SingletonDemoHandler{
		private static SingletonDemo instance = new SingletonDemo();
	}    
	//外部暴露
	public static SingletonDemo getInstance(){
		return SingletonDemoHandler.instance;
	}
}
```

上一篇： Java日期时间类详解

下一篇：一文读懂SPI机制

已有0条评论

0/150

提交

热门评论

查看更多评论

目 录

目录