1. IT分享知识网首页
  2. 开发语言
  3. java

Java内存模型之可见性

老牧童 • • java, 未分类

Java内存模型之可见性1 什么是可见性问题 2 为什么会有可见性问题 3 JMM 的抽象 主内存和本地内存 4 Happens Before 原则 5 volatile 关键字 6 能保证可见性的措施 7 升华 对 synchronized 可见性的正确理解 java 内存可见性

大家好，欢迎来到IT知识分享网。

文章目录

1.什么是可见性问题

首先来看第一个代码案例，演示什么是可见性问题。

/ * 演示可见性带来的问题 */ public class FieldVisibility { 
    int a = 1; int b = 2; private void change() { 
    a = 3; b = a; } private void print() { 
    System.out.println("b = " + b + ", a = " + a); } public static void main(String[] args) { 
    while (true) { 
    FieldVisibility test = new FieldVisibility(); new Thread(new Runnable() { 
    @Override public void run() { 
    try { 
    Thread.sleep(1); } catch (InterruptedException e) { 
    e.printStackTrace(); } test.change(); } }).start(); new Thread(new Runnable() { 
    @Override public void run() { 
    try { 
    Thread.sleep(1); } catch (InterruptedException e) { 
    e.printStackTrace(); } test.print(); } }).start(); } } }

关于上述程序的运行结果，我们可以很容易分析得到如下三种情况：

  • b = 2, a = 3
  • b = 2, a = 1
  • b = 3, a = 3

然而，在实际运行过程中，还有可能会出现第四种情况（概率低），即 b = 3, a = 1。这是因为 a 虽然被修改了，但是其他线程不可见，而 b 恰好其他线程可见，这就造成了 b = 3, a = 1。

在这里插入图片描述

2.为什么会有可见性问题

接下来，尝试分析第二个案例。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

至此，解答一个问题：为什么会有可见性问题？

  • CPU有多级缓存，导致读的数据过期。
  • 高速缓存的容量比主内存小，但是速度仅次于寄存器，所以在CPU和主内存之间就多了Cache层。
  • 线程间的对于共享变量的可见性问题不是直接由多核引起的，而是由多缓存引起的。
  • 如果所有的核心都只用一个缓存，那么也就不存在内存可见性问题了。
  • 每个核心都会将自己需要的数据读到独占缓存中，数据修改后也是写入到缓存中，然后等待刷入到主存中。所以会导致有些核心读取的值是一个过期的值。

在这里插入图片描述

3.JMM的抽象：主内存和本地内存

3.1 什么是主内存和本地内存

Java作为高级语言，屏蔽了这些底层细节，用JMM定义了一套读写内存数据的规范，虽然我们不再需要关心一级缓存和二级缓存的问题，但是，JMM抽象了主内存和本地内存的概念。

这里说的本地内存并不是真的是一块给每个线程分配的内存，而是JMM的一个抽象，是对于寄存器、一级缓存、二级缓存等的抽象。

在这里插入图片描述

在这里插入图片描述

3.2 主内存和本地内存的关系

JMM有以下规定：

  1. 所有的变量都存储在主内存中，同时每个线程也有自己独立的工作内存，工作内存中的变量内容是主内存中的拷贝。
  2. 线程不能直接读写主内存中的变量，而是只能操作自己工作内存中的变量，然后再同步到主内存中。
  3. 主内存是多个线程共享的，但线程间不共享工作内存，如果线程间需要通信，必须借助主内存中转来完成。

总结：所有的共享变量存在于主内存中，每个线程有自己的本地内存，而且线程读写共享数据也是通过本地内存交换的，所以才导致了可见性问题。

4.Happens-Before原则

4.1 什么是Happens-Before

下面的两种解释其实是一种意思。

Happens-Before规则是用来解决可见性问题的：在时间上，动作 A 发生在动作 B 之前，B 保证能看见 A，这就是Happens-Before。

两个操作可以用Happens-Before来确定它们的执行顺序：如果一个操作Happens-Before于另一个操作，那么我们说第一个操作对于第二个操作是可见的。

4.2 什么不是Happens-Before

两个线程没有相互配合的机制，所以代码 X 和 Y 的执行结果并不能保证总被对方看到的，这就不具备Happens-Before。

4.3 Happens-Before规则有哪些

(1) 单线程规则

在这里插入图片描述

(2) 锁操作（synchronized和Look）

在这里插入图片描述

在这里插入图片描述

(3) volatile变量

在这里插入图片描述

(4) 线程启动

在这里插入图片描述

(5) 线程join

在这里插入图片描述

(6) 传递性

传递性：如果 hb(A,B) 而且 hb(B,C)，那么可以推出 hb(A,C)。

(7) 中断

中断：一个线程被其他线程 interrupt 时，那么检测中断（isInterrupted）或者抛出 InterruptedException 一定能看到。

(8) 构造方法

构造方法：对象构造方法的最后一行指令Happens-Before于 finalize() 方法的第一行指令。

(9) 工具类的Happens-Before原则

  • 线程安全的容器get一定能看到在此之前的put等存入动作
  • CountDownLatch
  • Semaphore
  • Future
  • 线程池
  • CyclicBarrier

4.4 演示：使用volatile修正可见性问题

Happens-Before有一个原则是：如果 A 是对 volatile 变量的写操作，B 是对同一个变量的读操作，那么 hb(A,B)。

根据上面的原则，可以使用 volatile 关键字解决本文开头第一个案例的可见性问题。

/ * 使用volatile关键字解决可见性问题 */ public class FieldVisibility { 
    int a = 1; volatile int b = 2; // 只给b加volatile即可 // writerThread private void change() { 
    a = 3; b = a; // 作为刷新之前变量的触发器 } // readerThread private void print() { 
    System.out.println("b = " + b + ", a = " + a); } public static void main(String[] args) { 
    while (true) { 
    FieldVisibility test = new FieldVisibility(); new Thread(new Runnable() { 
    @Override public void run() { 
    try { 
    Thread.sleep(1); } catch (InterruptedException e) { 
    e.printStackTrace(); } test.change(); } }).start(); new Thread(new Runnable() { 
    @Override public void run() { 
    try { 
    Thread.sleep(1); } catch (InterruptedException e) { 
    e.printStackTrace(); } test.print(); } }).start(); } } }

这里体现了 volatile 的一个很重要的功能：近朱者赤。给 b 加了 volatile，不仅 b 被影响，也可以实现轻量级同步。

b 之前的写入（对应代码b=a）对读取 b 后的代码（print b）都可见，所以在 writerThread 里对 a 的赋值，一定会对 readerThread 里的读取可见，所以这里的 a 即使不加 volatile，只要 b 读到是 3，就可以由Happens-Before原则保证了读取到的都是 3 而不可能读取到 1。

5.volatile关键字

5.1 volatile是什么

volatile是一种同步机制，比synchronized或者Lock相关类更轻量，因为使用volatile并不会发生上下文切换等开销很大的行为。

如果一个变量被修饰成volatile，那么JVM就知道了这个变量可能会被并发修改。

但是开销小，相应的能力也小，虽然说volatile是用来同步地保证线程安全的，但是volatile做不到synchronized那样的原子保护，volatile仅在很有限的场景下才能发挥作用。

5.2 volatile的适用场合

(1) 不适用于a++

import java.util.concurrent.atomic.AtomicInteger; / * volatile的不适用场景 */ public class NoVolatile implements Runnable { 
    volatile int a; AtomicInteger realA = new AtomicInteger(); @Override public void run() { 
    for (int i = 0; i < 10000; i++) { 
    a++; realA.incrementAndGet(); } } public static void main(String[] args) throws InterruptedException { 
    Runnable r = new NoVolatile(); Thread thread1 = new Thread(r); Thread thread2 = new Thread(r); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println(((NoVolatile) r).a); System.out.println(((NoVolatile) r).realA.get()); } }

在这里插入图片描述

(2) 适用场景一

如果一个共享变量自始至终只被各个线程赋值，而没有其他的操作，那么就可以用volatile来代替synchronized或者代替原子变量，因为赋值自身是有原子性的，而volatile又保证了可见性，所以就足以保证线程安全。例如，boolean flag 操作。

注意：volatile 适用的关键并不在于 boolean 类型，而在于和之前的状态是否有关系。

在下面的程序中，setDone() 的时候，done 变量只是被赋值，而没有其他的操作，所以是线程安全的。

import java.util.concurrent.atomic.AtomicInteger; / * volatile的适用场景 */ public class UseVolatile implements Runnable { 
    volatile boolean done = false; AtomicInteger realA = new AtomicInteger(); @Override public void run() { 
    for (int i = 0; i < 10000; i++) { 
    setDone(); realA.incrementAndGet(); } } private void setDone() { 
    done = true; } public static void main(String[] args) throws InterruptedException { 
    Runnable r = new UseVolatile(); Thread thread1 = new Thread(r); Thread thread2 = new Thread(r); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println(((UseVolatile) r).done); System.out.println(((UseVolatile) r).realA.get()); } }

在这里插入图片描述

在下面的程序中，虽然 done 变量是 boolean 类型的，但 flipDone() 的时候，done 变量取决于之前的状态，所以是线程不安全的。

import java.util.concurrent.atomic.AtomicInteger; / * volatile的不适用场景 */ public class NoUseVolatile implements Runnable { 
    volatile boolean done = false; AtomicInteger realA = new AtomicInteger(); @Override public void run() { 
    for (int i = 0; i < 10000; i++) { 
    flipDone(); realA.incrementAndGet(); } } private void flipDone() { 
    done = !done; } public static void main(String[] args) throws InterruptedException { 
    Runnable r = new NoUseVolatile(); Thread thread1 = new Thread(r); Thread thread2 = new Thread(r); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println(((NoUseVolatile) r).done); System.out.println(((NoUseVolatile) r).realA.get()); } }

在这里插入图片描述

(3) 适用场景二

作为刷新之前变量的触发器。

在这里插入图片描述

5.3 volatile的两点作用

可见性：读一个volatile变量之前，需要先使相应的本地缓存失效，这样就必须到主内存读取最新值，写一个volatile属性会立即刷入到主内存。

禁止指令重排序优化：解决单例双重锁乱序问题。

5.4 volatile和synchronized的关系

volatile在这方面可以看做是轻量版的synchronized：如果一个共享变量自始至终只被各个线程赋值，而没有其他的操作，那么就可以用volatile来代替synchronized或者代替原子变量，因为赋值自身是有原子性的，而volatile又保证了可见性，所以就足以保证线程安全。

5.5 volatile小结

  1. volatile修饰符适用于以下场景：某个属性被多个线程共享，其中有一个线程修改了此属性，其他线程可以立即得到修改后的值，比如 boolean flag 或者作为触发器，实现轻量级同步。
  2. volatile属性的读写操作都是无锁的，它不能替代synchronized，因为它没有提供原子性和互斥性。因为无锁，不需要花费时间在获取锁和释放锁上，所以说它是低成本的。
  3. volatile只能作用于属性，我们用volatile修饰属性，这样compilers就不会对这个属性做指令重排序。
  4. volatile提供了可见性，任何一个线程对其的修改将立马对其他线程可见。volatile属性不会被线程缓存，始终从主存中读取。
  5. volatile提供了happens-before保证，对volatile变量 v 的写入happens-before所有其他线程后续对 v 的读操作。
  6. volatile可以使得long和double的赋值是原子的。关于long和double的原子性，可以参考这篇文章。

6.能保证可见性的措施

除了volatile可以让变量保证可见性外，synchronized、Lock、并发集合、Thread.join() 和 Thread.start() 等都可以保证可见性。

具体看上述happens-before原则的规定。

7.升华：对synchronized可见性的正确理解

synchronized不仅保证了原子性，还保证了可见性。

synchronized不仅让被保护的代码安全，还近朱者赤。

免责声明：本站所有文章内容,图片，视频等均是来源于用户投稿和互联网及文摘转载整编而成，不代表本站观点，不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益，请在线联系站长,一经查实,本站将立刻删除。 本文来自网络,若有侵权，请联系删除，如若转载，请注明出处：https://haidsoft.com/131082.html

赞 (0)
老牧童老牧童
0
上一篇 2025-08-10 17:45
下一篇 2025-08-10 18:00

相关推荐

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

关注微信