Java多线程：Volatile关键字

最新推荐文章于 2025-03-10 15:51:20 发布

原创最新推荐文章于 2025-03-10 15:51:20 发布 · 290 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#Java内存模型 #volatile #线程安全

Java 专栏收录该内容

51 篇文章

订阅专栏

本文详细解析了Java中volatile关键字的功能及其实现原理，包括其保证变量可见性和禁止指令重排序的特性，以及在多线程环境下的应用案例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

volatile关键在是在java 5后得到完善后，才被推广使用的。

java内存模型中对volatile型变量的特殊规则

volatile关键字的使用方法：volatile关键字是java虚拟机提供的最轻量级的同步机制。

volatile关键字的作用：当一个变量定义为volatile之后，它将具备两种特性:

特性一：保证此变量对所有线程的可见性，这里的“可见性”是指当一条线程修改了这个变量的值，新值对于其他线程来说是可以立即得知的，而普通变量不能做到这一点，普通变量的值在线程间传递均需要通过主内存来完成。

虽然volatile关键字能够保证变量在多线程之间的可见性，保证了数据一致性，但是依然存在并发安全问题，这是因为某些运算操作不具有原子性。如下面的示例代码：

package multithreads;

public class VolatileTest {
	public static volatile int race = 0;
	
	public static void increase() {
		race++;
	}
	
	private static final int THREAD_COUNT = 20;
	
	public static void main(String[] args) {
		Thread[] threads  = new Thread[THREAD_COUNT];
		
		for(int i = 0; i<THREAD_COUNT;i++) {
			threads[i] = new Thread(new Runnable() {

				@Override
				public void run() {
					for(int i = 0;i<1000;i++) {
						increase();
					}
					
				}
				
			});
			
			threads[i].start();
		}
		
		while(Thread.activeCount() > 1) {
			Thread.yield();
		}
		
		System.out.println(race);
	}
}

这段代码的含义是：存在20个线程，每个线程对rece变量进行1000次加1操作，如果是多线程安全的，那么最后rece的值为20*1000，但是实际的执行结果是，不为20000，而且多次执行的结果是不相同的。

再深入的分析一下，使用java自带的反编译工具，在dos中执行javap -verbose VolatileTest，得到反编译结果。

在上面编译结果中，将race++的实现过程是分为三步进行的，所以当一个线程A获得race的当前值，存放在数据栈顶，但是有可能在执行add的时候，其他线程B正好也完成了对race的操作，也就是现在在栈顶存放的race的值已经失效了，所以当A线程对race执行完加1操作后，较小的值会写入内存中。

为了保证volatile修饰变量的安全性，在不符合以下两条规则的运算场景中，可以使用加锁（synchronized关键字或java.util.concurrent中的原子类）保证原子性。

（1）远算结果并不依赖变量的当前值，或者能够确保只有单一的线程修改变量的值

（2）变量不需要与其他的状态变量共同参与不变约束

特性二：volatile变量的第二个语义是禁止指令重排序优化

注意这里所说的重排序优化是机器级的优化操作，代码的提前执行是指该行代码对应的汇编代码被提前执行了。

现在以双检测单例模式作为实例，分析一下volatile关键字在编译过程中具体干了什么。

public class Singleton {
	private volatile static Singleton instance;
	
	public static Singleton getInstance() {
		if(instance ==null) {
			synchronized(Singleton.class) {
				if(instance == null) {
					instance = new Singleton();
				}
			}
		}
		
		return instance;
	}
	
	public static void main(String[] args) {
		Singleton.getInstance();
	}
}

编译后，对instance变量赋值部分如下所示：

在含有volatile关键字的代码汇编代码中发现，对volatile变量赋值后，会多执行一个“lock addl $0x0,(%esp)”操作，这个操作相当于一个内存屏障（指重排序时不能把后面的指令重排序到内存屏障之前的位置），当只有一个CPU访问时，并不需要内存屏障；但是如果有两个或更多CPU访问同一块内存，且其中有一个在观测另一个，就需要内存屏障来保证一致性了。这句指令中的“addl $0x0,(%esp)”(把ESP寄存器的值加0)显然是一个空操作，关键在与lock前缀，查询IA32手册，它的作用是使得本CPU的cache写入了内存，该写入动作也会引起别的CPU或者别的内核无效化其cache，这种操作相当于对cache中的变量做了一次java内存模型中所说的“store和write”操作。所以通过这样一个空操作，可让前面volatile变量的修改对其他CPU立即可见。

现在说一下volatile禁止重排序功能，从硬件架构上讲，指令重排序是指CPU采用了允许将多条指令不按程序规定的顺

序分开发送给各相应电路单元处理，但并不是说指令任意重排，CPU需要能正确处理指令依赖情况以保障程序能都出正

确的执行结果。指令重排序看起来是乱序的，但是实际是有序的。所以，lockaddl $0x0,(%esp)指令把修改同步到内存时

，意味着所以之前的操作都已经执型完成，（对ESP寄存器中数值的操作存在数据依赖性，只有保证之前

对同一数据的操作已经完成了，才能执行同步操作），这样便形成了“指令重排序无法越过内存屏障”的效果。

使用volatile的意义

在某些情况下，volatile的同步机制的性能确实要优于锁（使用synchronized或java.util.concurrent包里面的锁），但是由于虚拟机对锁实行的许多消除和优化，使得我们很难量化地认为volatile就会比synchronized快多少。如果让volatile自己与自己比较，那可以确定一个原则：volatile变量读操作的性能消耗与普通变量几乎没什么差别，但是写操作则可能会慢一些，因为它需要在本地代码中插入许多内存屏蔽指令来保证处理器不发生乱序执行。不过即便如此，大多数场景下volatile的总开销仍然要比锁低。

java内存模型对volatile专门定义了特殊的访问规则：假定T表示一个线程，V和W分别表示两个volatile型变量，那么在进行read、load、use、assign、store、write操作时需要满足以下规则：

（1）只有当线程T对变量V执行的前一个动作是load的时候，线程T才能对变量V执行use动作；并且，只有当线程T对变量V执行的后一个动作是use的时候，线程T才能对变量V执行load动作。线程T对变量V的use动作可认为是和线程T对变量V的load、read动作相关联，必须连续一起出现（这条规则要求在工作内存中，每次使用V前都必须先从主内存刷新最新的值，用于保证能看见其他线程对变量V所做的修改后的值）。

（2）只有当线程T对变量V执行的前一个动作是assign的时候，线程T才能对变量V执行store动作；并且，只有当线程T对变量V执行的后一个动作是store的时候，线程T才能对变量V执行assign动作。线程T对变量V的assign动作可以认为是和线程T对变量V的store和write动作相关联，必须连续一起出现（这条规则要求在工作内存中，每次修改V后都必须立刻同步回主内存中，用于保证其他线程可以看到自己对变量V所做的修改）。

（3）假设动作A是线程T对变量V实施的use或assign动作，假定动作F是和动作A相关联的load或store动作，假定动作P是和动作F相应的对变量V的read或write动作；类似的，假定动作B是线程T对变量W实施的use或assign动作，假定动作G是和动作B相关联的load或store动作，假定动作Q是和动作G相应的对变量W的read或write动作。如果A先于B,那么P先于Q（这条规则要求volatile修饰的变量不会被指令重排序优化，保证代码的执行顺序与程序的顺序相同）。