java多线程之内存可见性

最新推荐文章于 2025-08-19 14:35:05 发布

weixin_33971130

最新推荐文章于 2025-08-19 14:35:05 发布

阅读量64

点赞数

CC 4.0 BY-SA版权

文章标签： java python

原文链接：https://my.oschina.net/u/3381212/blog/1929840

本文详细介绍了Java多线程环境下实现内存可见性的方法，包括synchronized关键字和volatile变量的作用原理及其使用注意事项。

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

2019独角兽企业重金招聘Python工程师标准>>>

前言：

谈到多线程，不可避免的就会谈到数据争用的问题，而要解决数据争用，就需要学习内存可见性相关的知识

一、共享变量在线程间的可见性：

首先对相关的几个名词进行解释：

1. 什么是“可见性”：一个线程对共享变量值的修改，能够及时被其它线程看到

2. 什么是“共享变量”：如果一个变量在多个线程的工作内存中都存在副本，那么这个变量就是这几个线程的共享变量

3. 什么是“线程的工作内存”：要了解这个，我们需要先了解一下java内存模型（JMM）

JMM描述了java程序中各种变量（线程共享变量）的访问规则，以及在JVM 中将变量存储到内存和从内存中取出变量这样的底层细节。

所有变量都存储在主内存中
每个线程都有自己独立的工作内存，里面保存该线程使用到的变量的副本（主内存中该变量的一份拷贝）

这里有两条规定：

线程对共享变量的所有操作都必须在自己的工作内存中进行，不能直接从主内存中读写
不同线程之间无法直接访问其他线程工作内存中的变量，线程间变量值的传递需要通过主内存来完成（主内存作为桥梁）

导致共享变量在线程间不可见的原因：

线程交叉执行
重排序结合线程交叉执行
共享变量更新后的值没有在工作内存和主内存间及时更新

因此，要实现共享变量的可见性，必须保证两点：

线程修改后的共享变量值能够及时从工作内存中刷新到主内存中
其他线程能够及时把共享变量的最新值从主内存更新到自己的工作内存

二、synchronized：

synchronized是java语言层面支持的可见性实现方式之一（不包括jdk1.5之后，concurrent并发包下的一些高级特性），它可以实现互斥锁（即实现同步），从而保证在任意一个时刻都只有一个线程在执行锁里的代码。线程执行互斥代码的过程如下：

在synchronized入口处获得互斥锁
清空工作内存
从主内存拷贝变量的最新副本到工作内存
执行锁内部代码
将更改后的共享变量的值刷新到主内存
程序退出synchronized语句块时释放互斥锁

package mkw.demo.syn;

public class SynchronizedDemo {
	//共享变量
    private boolean ready = false;
    private int result = 0;
    private int number = 1;   
    //写操作
    public synchronized void write(){
    	ready = true;	      				//1.1				
    	number = 2;		                    //1.2			    
    }
    //读操作
    public synchronized void read(){			   	 
    	if(ready){					//2.1
    		result = number*3;	 	//2.2
    	}   	
    	System.out.println("result的值为：" + result);
    }

    //内部线程类
    private class ReadWriteThread extends Thread {
    	//根据构造方法中传入的flag参数，确定线程执行读操作还是写操作
    	private boolean flag;
    	public ReadWriteThread(boolean flag){
    		this.flag = flag;
    	}
        @Override                                                                    
        public void run() {
        	if(flag){
        		//构造方法中传入true，执行写操作
        		write();
        	}else{
        		//构造方法中传入false，执行读操作
        		read();
        	}
        }
    }

    public static void main(String[] args)  {
    	SynchronizedDemo synDemo = new SynchronizedDemo();
    	//启动线程执行写操作
    	synDemo .new ReadWriteThread(true).start();
    	try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	//启动线程执行读操作
    	synDemo.new ReadWriteThread(false).start();
    }
}

三、volatile：

特点：

能够保证volatile变量的可见性
不能保证volatile变量复合操作的原子性

volatile如何实现内存可见性：

深入来说：通过加入内存屏障和禁止重排序优化来实现的。

对volatile变量执行写操作时，会在写操作后加入一条store屏障指令，将缓存区中的值强制刷新到主内存
对volatile变量执行读操作时，会在读操作前加入一条load屏障指令，强制使缓存区中的缓存失效，每次都从主内存中读最新的值

通俗地讲：volatile变量在每次被线程访问时，都强制从主内存中读取该变量的值，而当该变量发生变化时，又会强制线程将最新的值刷新到主内存。这样任何时刻，不同线程总能看到该变量的最新值。

要保证操作的原子性，有以下解决方案：

使用synchronized关键字

2. 使用ReentrantLock（java.util.concurrent.locks包下）

3. 使用AutomicInteger（java.util.concurrent.automic包下）

volatile使用注意事项：

由于volatile不能保证原子性，线程可能发生交叉执行，所以可能会产生一些问题：

要在多线程中安全的使用volatile变量，必须同时满足以下条件：

1. 对变量的写入操作不依赖当前值

不满足：number++、count=count*5等
满足：boolean变量、记录温度变化的变量等

2. 该变量没有包含在具有其他变量的不变式中（若程序中有多个volatile变量，每个volatile变量的状态要独立于其他volatile变量）

不满足：不变式low<up

写代码时会发现，很多时候至少都会和上述两个条件之一冲突，因此volatile并没有synchronized使用广泛

四、synchronized和volatile的比较

1. volatile不需要加锁，比synchronized更轻量级，不会阻塞线程，；

2. 从内存可见性角度，volatile读相当于加锁，volatile写相当于解锁；

3. synchronized既能保证可见性，又能保证原子性，而volatile只能保证可见性，无法保证原子性。

volatile使用有诸多限制，因此没有synchronized使用广泛，但由于volatile比synchronized更轻量，执行效率更高，因此如果能保证线程安全的情况下，尽可能选择volatile

附录：

指令重排序：代码书写顺序与实际执行的顺序不同，指令重排序是编译器或处理器为了提高程序性能而做的优化（只有数据依赖关系才会禁止指令重排序，参见下图的sum值，依赖num1+num2，故该行不能重排序）
as-if-serial语义：无论如何重排序，程序执行的结果应该与代码顺序执行结果一致（java编译器、运行时和处理器都会敖政java在单线程下遵循as-if-serial语义）