搜 索

Java并发编程丨Java 内存模型

  • 175阅读
  • 2021年12月18日
  • 0评论
首页 / 默认分类 / 正文

前言

已知导致可见性的原因是缓存,导致有序性的原因是编译优化,那解决可见性、有序性最直接的办法就是禁用缓存编译优化。但是,这样问题虽然解决了,我们程序的性能可就堪忧了。
合理的方案应该是按需禁用缓存以及编译优化。而 Java 内存模型规范了 JVM 如何提供按需禁用缓存和编译优化的方法。
Java 内存模型(Java Memory Model),简称 JMM,它是一种抽象的概念,并不真实存在,它描述的一组规则或规范,通过这组规范定义了程序中各个变量的访问方式。

关键字 synchronized

在 Java 中,对基本数据类型的变量的读取赋值操作是原子性操作,即这些操作是不可被中断的,要么执行,要么不执行。

对于 32 位系统来说,long 类型数据和 double 类型数据,它们的读写并非原子性的,也就是说如果存在两条线程同时对 long 类型或者 double 类型的数据进行读写,是存在相互干扰的。因为对于 32 位虚拟机来说,每次原子读写是 32 位,而 long 和 double 都是 64 位的存储单元,这样会导致一个线程 A 在写时,操作完成前 32 位的原子操作后,轮到线程 B 读取时,恰好只读取来后 32 位的数据,这样可能会读取到一个即非原值又不是线程修改值的变量,它可能是“半个变量”的数值,即 64 位数据被两个线程分成了两次读取。

Java 内存模型只保证了基本读取和赋值是原子性操作,如果要实现更大范围操作的原子性,可以通过 synchronizedLock 来实现。由于 synchronizedLock 能够保证任一时刻只有一个线程执行该代码块,那么自然就不存在原子性问题了,从而保证了原子性。
Java 语言提供的 synchronized 关键字,就是锁的一种实现。synchronized 它并不能改变 CPU 时间片切换的特点,只是当其他线程要访问这个资源时,发现锁还未释放,所以只能在外面等待,在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。
synchronized 关键字可以用来修饰方法,也可以用来修饰代码块,基本使用示例如下所示:

class X {
    
  // 修饰非静态方法
  synchronized void say() {
    // 临界区
  }
    
  // 修饰静态方法
  synchronized static void eat() {
    // 临界区
  }
    
  // 修饰代码块
  Object obj = new Object();
  void fly() {
    synchronized(obj) {
      // 临界区
    }
  }
}  

注意:当修饰静态方法的时候,锁定的是当前类的 Class 对象,在上面的例子中就是 Class X;当修饰非静态方法的时候,锁定的是当前实例对象 this。

关键字 volatile

JVM 启动之后,操作系统会为 JVM 进程分配一定的内存空间,这部分内存空间就称为“主内存”。另外 Java 程序的所有工作都由线程来完成,而每个线程都会有一小块内存,称为“工作内存”,Java 中的线程在执行的过程中,会先将数据从主内存中复制到线程的工作内存,然后再执行计算,执行计算之后,再把计算结果刷新到“主内存”中。
导致可见性问题
这种工作内存与主内存同步延迟现象就会造成可见性问题,对此,Java 提供了关键字 volatile 来保证可见性。
关键字 volatile 的意义就是禁用 CPU 缓存。当一个共享变量被 volatile 修饰时,它会保证修改的值会立即被更新到主存,当有其他线程需要读取时,它会去内存中读取新值。

关键字 final

当你使用关键字 final 修饰某个类时,此类就不能被继承;修饰某个方法时,此方法可以被重载。
在 JDK 1.5 以后 Java 内存模型对 final 类型变量的重排进行了约束。只要我们提供正确构造函数没有“逸出”,就不会出问题了。

this 逸出

虽然 final 域写重排序规则可以确保我们在使用一个对象引用的时候该对象的 final 域已经在构造函数被初始化过了。但有一个前提条件的,也就是:在构造函数,不能让这个被构造的对象被其他线程可见,也就是说该对象引用不能在构造函数中“溢出”。
举个例子:在构造函数里面,变量 x 和变量 test 之间并没有数据依赖关系,它们的初始化顺序就可能被重排序:可能先初始化 test 再初始化 x。而将 this 赋值给了全局变量 test,这就是“逸出”,多线程通过 test 读取 x 是有可能读到 0 的。

public class FinalReferenceEscapeTest {

    private final int x;
    private FinalReferenceEscapeTest test;

    // 错误的构造函数
    public FinalReferenceEscapeTest() {
        x = 1;
        // 此处就是讲 this 逸出
        test = this;
    }

    public void write(){
        new FinalReferenceEscapeTest();
    }

    public void read(){
        // 线程可能读取到 test == null
        if(test != null){
            // 有可能读取到 x 为 0
            int y = test.x;
        }
    }
}

Happens-Before 原则

除了可以用关键字 synchronizedvolatile 来保证有序性与可见性。除此之外,Java 还提供了 Happens-Before 规则。Happens-Before,直接翻译“先行发生”,但它不是说前面一个操作发生在后续操作的前面,它真正要表达的是:前面一个操作的结果对后续操作是可见的。

程序的顺序性规则

这条规则是指在一个线程中,按照程序顺序,前面的操作 Happens-Before 于后续的任意操作。

public class Example {
    int x = 0;
    /**
     * 告诉编译器,对这个变量的读写,不能使用 CPU 缓存,必须从内存中读取或者写入
     */
    volatile boolean v = false;

    public void writer() {
        x = 42;
        // 更新 v 为 true
        v = true;
    }

    public void reader() {
        if (v == true) {
            System.out.println("此时的 x 为:" + x);
        }
    }
}

按照程序的顺序,第 9 行代码 “x = 42;” Happens-Before 于第 11 行代码 “v = true;”,这比较符合单线程里面的思维:程序前面对某个变量的修改一定是对后续操作可见的。
在一个线程内,按照程序代码顺序,书写在前面的操作先行发生于书写在后面的操作。准确地说,应该是控制流顺序而不是程序代码顺序,因为要考虑分支、循环等结构。

volatile 变量规则

这条规则是指对一个 volatile 变量的写操作, Happens-Before 于后续对这个 volatile 变量的读操作。

管程中锁定规则

这条规则是指对一个锁的解锁 Happens-Before 于后续对这个锁的加锁。一个 unlock 操作先行发生于后面对同一个锁的 lock 操作。这里必须强调的是同一个锁,而"后面"是指时间上的先后顺序。
关键字 synchronized 是 Java 语言对管程的实现。管程中的锁在 Java 里是隐式实现的,例如下面的代码,在进入同步块之前,会自动加锁,而在代码块执行完会自动释放锁,加锁以及释放锁都是编译器帮我们实现的。

synchronized (this) { //此处自动加锁
  // x 是共享变量,初始值为 10
  if (this.x < 2021) {
    this.x = 2021; 
  }  
} //此处自动解锁

假设 x 的初始值是 10,线程 A 执行完代码块后 x 的值会变成 2021(执行完自动释放锁),线程 B 进入代码块时,能够看到线程 A 对 x 的写操作,也就是线程 B 能够看到 x==2021。

线程的启动规则

它是指主线程 A 启动子线程 B 后,子线程 B 能够看到主线程在启动子线程 B 前的操作。换句话说就是,如果线程 A 调用线程 B 的 start() 方法(即在线程 A 中启动线程 B),那么该 start() 操作 Happens-Before 于线程 B 中的任意操作。

Thread B = new Thread(()->{
  // 主线程调用 B.start()之前
  // 所有对共享变量的修改,此处皆可见
  // 此例中,num==2233
});
// 此处对共享变量 num 修改
num = 2233;
// 主线程启动子线程
B.start();

线程的等待规则

这条是关于线程等待的。它是指主线程 A 等待子线程 B 完成(主线程 A 通过调用子线程 B 的 join() 方法实现),当子线程 B 完成后(主线程 A 中 join() 方法返回),主线程能够看到子线程的操作。当然所谓的“看到”,指的是对共享变量的操作。
换句话说就是,如果在线程 A 中,调用线程 B 的 join() 并成功返回,那么线程 B 中的任意操作 Happens-Before 于该 join() 操作的返回。

Thread B = new Thread(()->{
  // 此处对共享变量var修改
  var = 66;
});
// 例如此处对共享变量修改,
// 则这个修改结果对线程B可见
// 主线程启动子线程
B.start();
B.join()
// 子线程所有对共享变量的修改
// 在主线程调用 B.join() 之后皆可见
// 此例中,var==66

线程的中断规则

对线程 interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生,可以通过 Thread.interrupted() 方法检测到是否有中断发生。

对象的终结规则

一个对象的初始化完成(构造函数执行结束)先行发生于它的 finalize() 方法的开始。

传递性规则

这条规则是指如果 A Happens-Before B,且 B Happens-Before C,那么 A Happens-Before C。就如同 10 > 9 且 9 > 8,那么 10 > 8。

参考

知乎专栏 - Java内存模型(JMM)总结
Java 全栈知识体系 - Java内存模型详解
打 赏
  • 支付宝
  • 微信
Alipay
WeChatPay
评论区
暂无评论
avatar