Java面试--Java线程--Volatile关键字

最新推荐文章于 2025-05-07 12:30:40 发布

原创最新推荐文章于 2025-05-07 12:30:40 发布 · 320 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#java #多线程 #jvm

Java基础专栏收录该内容

24 篇文章

订阅专栏

本文探讨了Java内存模型（JMM）的概念，包括主内存与工作内存的划分，以及内存交互的8种操作。重点讲解了volatile关键字的三大特性：原子性、可见性和有序性，指出其无法保证复合操作的原子性。通过实例说明了volatile如何在并发环境中确保数据的可见性和有序性，但无法保证原子性。

我们先从java内存开始讲起。

JMM。

什么是JMM？

JMM即为JAVA 内存模型（java memory model）。因为在不同的硬件生产商和不同的操作系统下，内存的访问逻辑有一定的差异，结果就是当你的代码在某个系统环境下运行良好，并且线程安全，但是换了个系统就出现各种问题。Java内存模型，就是为了屏蔽系统和硬件的差异，让一套代码在不同平台下能到达相同的访问结果。

内存划分

JMM规定了内存主要划分为主内存和工作内存两种。此处的主内存和工作内存跟JVM内存划分(栈、堆、方法区)是在不同的层次上进行的。如果非要对应起来，主内存就是Java堆中的对象实例部分。工作内存对应的是栈中的部分区域。从更底层的来说，主内存对应的是硬件的物理内存。而工作内存对应的是寄存器和高速缓存。

jvm在设计时候考虑到，如果Java线程每次读取和写入变量都直接操作主内存，那么对性能影响会比较大。所以每条线程拥有自己的工作内存，工作内存中的变量是主内存中的一份拷贝。线程对变量的读取和写入，直接在工作内存中操作，而不能直接去操作主内存的变量。但是这样就会出现一个问题，当一个线程修改了自己工作内存中的变量，对其他线程是不可见的。会导致线程不安全。

内存交互操作

内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可再分的

lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态
unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用
load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令
assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中
store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用
write 　（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中

　JMM对这八种指令的使用，制定了如下规则：

不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
不允许一个线程将没有assign的数据从工作内存同步回主内存
一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作
一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
对一个变量进行unlock操作之前，必须把此变量同步回主内存

来举个例子给看

i= i+1

假设i初始值为0，当只有一个线程执行它时，结果肯定得到 1。当两个线程执行时呢

线程1 ： load i from 主存 // i =0;

i+1 // i =1

线程2 ： load i from 主存 // 因为线程1还没有将i的值写回主存，所以i现在是 0

i +1 // i = 1

线程1：save i to 主存

线程2：save i to 主存

如果两个线程都按照上面的执行流程，那么i最后的值居然是1 了。如果最后的写回生效的慢，你再读i的值，都可能是0。这就是缓存不一致问题。JMM主要就是围绕着如何在并发过程中如何处理原子性，可见性和有序性3个特征来建立的。通过解决这三个问题，可以解除缓存不一致的问题，而volatile跟可见性和有序性都有关。

Volatile三个特性：

1.原子性(Atmicity)

java中，对基本数据类型的读取和赋值都是原子性操作，所谓原子性操作就是对这些操作是不可中断的，要做就一定要做完，要么就没有执行。

i = 2;

j = i;

i++;

i = i+1;

上面4个操作中，i=2 是读取操作，必定是原子性操作。

i++为什么线程不安全

j = i ，是两步，一是读取i的值，然后再赋值给j。这就是两步操作了。

i ++ 和 i = i +1 其实是等效的。读取i 的值，+1 ，然后写回主存。是3步操作了。

JMM只实现了基本的原子性，像上面i++ 的操作，必须借助synchronized和lock来保证整段代码的原子性。线程在释放锁之前，必然会把i的值刷回主存。

2.可见性（Visibility）：

java就是利用volatile提供可见性。当一个变量被volatile修饰时，那么它的修改会立即刷新到主存，当其他线程需要读取该变量时，会去内存读取新值，而普通变量则不能保证这一点。，

其实通过synchronized和lock也能保证可见性，线程在释放锁之前，会把共享变量值都刷回主存，但是synchronized和lock的开销很大。

3.有序性（Ordering）

JMM是允许编译器和处理器对指令重排序的，但是规定了as-if-serial 语义，不管怎么重排序，程序的执行结果不能改变，比如下面。

double pi = 3.14 //A

double r = 1； // B

double s = pi *r *r // C

上面的语句，可以按照A->B->C来执行，但是也可以B-> A -> C来执行。因为A和B是独立的语句，而C依赖于A、B。所以A、B可以重排序，但是C不能排到A、B前面。JMM保证了重排序不会影响单线程的执行。但是在多线程容易出问题。

int a = 0;
boolean flag = false;

public void write() {
    a = 2;              //1
    flag = true;        //2
}

public void multiply() {
    if (flag) {         //3
        int ret = a * a;//4
    }
    
}

假设两个线程执行了上述代码，线程1先执行write。随后线程2再执行multipy。

write方法里的1和2做了重排序，线程1对flag赋值为true，随后执行线程2，ret直接出结果，再到线程1，这时候a的值才是2，迟了一步。

这时候给flag加上volatile关键字，禁止重排序。可以确保有序性。

另外，JMM具备一些先天的有序性，不需要通过任何手段就可以保证的有序性，被称为happens-before原则。

程序顺序规则：一个线程中的每个操作，happens-before于该线程中的任意后续操作
监视器锁规则：对一个线程的解锁，happens-before于随后对这个线程的加锁
volatile变量规则：对一个volatile域的写，happens-before于后续对这个volatile域的读
传递性：如果A happens-before B ,且 B happens-before C, 那么 A happens-before C
start()规则：如果线程A执行操作ThreadB_start()(启动线程B) , 那么A线程的ThreadB_start()happens-before 于B中的任意操作
join()原则：如果A执行ThreadB.join()并且成功返回，那么线程B中的任意操作happens-before于线程A从ThreadB.join()操作成功返回。
interrupt()原则：对线程interrupt()方法的调用先行发生于被中断线程代码检测到中断事件的发生，可以通过Thread.interrupted()方法检测是否有中断发生
finalize()原则：一个对象的初始化完成先行发生于它的finalize()方法的开始