• Java内存模型JMM


    一、定义

    很多人分不清【java 内存结构】与【java 内存模型】,【java 内存结构】指的是jvm的内存分区,例如:堆、程序计数器、虚拟机栈等这些,【java 内存模型】是 Java Memory Model(JMM)的意思。

    简单的说,JMM 定义了一套在多线程读写共享数据时(成员变量、数组)时,对数据的可见性、有序性、和原子性的规则和保障。

    二、原子性

      两个线程对初始值为 0 的静态变量一个做自增,一个做自减,各做 5000 次,结果不一定是0。

    例如:对于 i++ 而言(i 为静态变量),实际会产生如下的 JVM 字节码指令:

      getstatic i // 获取静态变量i的值

       iconst_1 // 准备常量1

       iadd // 加法

       putstatic i // 将修改后的值存入静态变量i

    而对应 i-- 也是类似: 

      getstatic i // 获取静态变量i的值

      iconst_1 // 准备常量1

      isub // 减法

      putstatic i // 将修改后的值存入静态变量i

    而 Java 的内存模型如下,完成静态变量的自增,自减需要在主存和线程内存中进行数据交换:

     如果是单线程以上 8 行代码是顺序执行(不会交错)没有问题:

    // 假设i的初始值为0
    getstatic i // 线程1-获取静态变量i的值 线程内i=0
    iconst_1 // 线程1-准备常量1
    iadd // 线程1-自增 线程内i=1
    putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=1
    getstatic i // 线程1-获取静态变量i的值 线程内i=1
    iconst_1 // 线程1-准备常量1
    isub // 线程1-自减 线程内i=0
    putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=0

    但多线程下这 8 行代码可能交错运行(为什么会交错?思考一下): 出现负数的情况:

    // 假设i的初始值为0
    getstatic i // 线程1-获取静态变量i的值 线程内i=0
    getstatic i // 线程2-获取静态变量i的值 线程内i=0
    iconst_1 // 线程1-准备常量1
    iadd // 线程1-自增 线程内i=1
    putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=1
    iconst_1 // 线程2-准备常量1
    isub // 线程2-自减 线程内i=-1
    putstatic i // 线程2-将修改后的值存入静态变量i 静态变量i=-1

    出现正数的情况:

    // 假设i的初始值为0
    getstatic i // 线程1-获取静态变量i的值 线程内i=0
    getstatic i // 线程2-获取静态变量i的值 线程内i=0
    iconst_1 // 线程1-准备常量1
    iadd // 线程1-自增 线程内i=1
    iconst_1 // 线程2-准备常量1
    isub // 线程2-自减 线程内i=-1
    putstatic i // 线程2-将修改后的值存入静态变量i 静态变量i=-1
    putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=1

    解决办法就是加锁,例如:synchronized

    三、可见性

    先来看一个现象,main 线程对 run 变量的修改对于 t 线程不可见,导致了 t 线程无法停止:

    static boolean run = true;
    public static void main(String[] args) throws InterruptedException {
    Thread t = new Thread(()->{
      while(run){
        // ....
      }
    });
    t.start();
    Thread.sleep(1000);
    run = false; // 线程t不会如预想的停下来
    }

    为什么呢?分析一下:

    1. 初始状态, t 线程刚开始从主内存读取了 run 的值到工作内存。

     2. 因为 t 线程要频繁从主内存中读取 run 的值,JIT 编译器会将 run 的值缓存至自己工作内存中的高 速缓存中,减少对主存中 run 的访问,提高效率

     3. 1 秒之后,main 线程修改了 run 的值,并同步至主存,而 t 是从自己工作内存中的高速缓存中读 取这个变量的值,结果永远是旧值

    解决办法:volatile(易变关键字)它可以用来修饰成员变量和静态成员变量,他可以避免线程从自己的工作缓存中查找变量的值,必须到 主存中获取它的值,线程操作 volatile 变量都是直接操作主存,

    但是一个线程对 volatile 变量的修改对另一 个线程可见, 不能保证原子性,仅用在一个写线程,多个读线程的情况。

    synchronized 语句块既可以保证代码块的原子性,也同时保证代码块内变量的可见性。但缺点是synchronized是属于重量级操作,性能相对更低。

    四、有序性

    先看一段代码

    int num = 0;
    boolean ready = false;
    // 线程1 执行此方法
    public void actor1(I_Result r) {
      if(ready) {
        r.r1 = num + num;
      } else {
        r.r1 = 1;
      }
    }
    // 线程2 执行此方法
    public void actor2(I_Result r) {
      num = 2;
      ready = true;
    }

    I_Result 是一个对象,有一个属性 r1 用来保存结果,问,可能的结果有几种?

    如果经过大量测试的话,会发现其中一种结果有可能为0,出现这种现象原因是指令重排,是 JIT 编译器在运行时的一些优化,这个现象需要通过大量测试才能复现。

    JVM 会在不影响正确性的前提下,可以调整语句的执行顺序,例如著名的 double-checked locking 模式实现单例

    public final class Singleton {
    private Singleton() { }
    private static Singleton INSTANCE = null;
    public static Singleton getInstance() {
      // 实例没创建,才会进入内部的 synchronized代码块
      if (INSTANCE == null) {
        synchronized (Singleton.class) {
          // 也许有其它线程已经创建实例,所以再判断一次
          if (INSTANCE == null) {
            INSTANCE = new Singleton();
          }
        }
      }
      return INSTANCE;
    }
    }

    但在多线程环境下,上面的代码是有问题的, INSTANCE = new Singleton() 对应的字节码为:

    0: new #2 // class cn/itcast/jvm/t4/Singleton
    3: dup
    4: invokespecial #3 // Method "<init>":()V
    7: putstatic #4 // Field
    INSTANCE:Lcn/itcast/jvm/t4/Singleton;

    其中4,7两步的顺序不是固定的,也许 jvm 会优化为:先将引用地址赋值给 INSTANCE 变量后,再执行
    构造方法,如果两个线程 t1,t2 按如下时间序列执行:

    时间1 t1 线程执行到 INSTANCE = new Singleton();
    时间2 t1 线程分配空间,为Singleton对象生成了引用地址(0 处)
    时间3 t1 线程将引用地址赋值给 INSTANCE,这时 INSTANCE != null7 处)
    时间4 t2 线程进入getInstance() 方法,发现 INSTANCE != null(synchronized块外),直接
    返回 INSTANCE
    时间5 t1 线程执行Singleton的构造方法(4 处)

    这时 t1 还未完全将构造方法执行完毕,如果在构造方法中要执行很多初始化操作,那么 t2 拿到的是将 是一个未初始化完毕的单例

    解决办法:对 INSTANCE 使用 volatile 修饰即可,可以禁用指令重排,但要注意在 JDK 5 以上的版本的 volatile 才 会真正有效

    五、happens-before

    happens-before 规定了哪些写操作对其它线程的读操作可见,它是可见性与有序性的一套规则总结, 抛开以下 happens-before 规则,JMM 并不能保证一个线程对共享变量的写,对于其它线程对该共享变量的读可见

    1、线程解锁 m 之前对变量的写,对于接下来对 m 加锁的其它线程对该变量的读可见

    static int x;
    static Object m = new Object();
    new Thread(()->{
      synchronized(m) {
        x = 10;
      }
    },"t1").start();
    new Thread(()->{
      synchronized(m) {
        System.out.println(x);
      }
    },"t2").start();

    2、线程对 volatile 变量的写,对接下来其它线程对该变量的读可见

    volatile static int x;
    new Thread(()->{
        x = 10;
    },"t1").start();
    new Thread(()->{
        System.out.println(x);
    },"t2").start();

    3、线程 start 前对变量的写,对该线程开始后对该变量的读可见

    static int x;
    x = 10;
    new Thread(()->{
        System.out.println(x);
    },"t2").start();

    4、线程结束前对变量的写,对其它线程得知它结束后的读可见(比如其它线程调用 t1.isAlive() 或t1.join()等待它结束)

    static int x;
    Thread t1 = new Thread(()->{
        x = 10;
    },"t1");
    t1.start();
    t1.join();
    System.out.println(x);

    5、线程 t1 打断 t2(interrupt)前对变量的写,对于其他线程得知 t2 被打断后对变量的读可见(通过t2.interrupted 或 t2.isInterrupted)

           static int x;
    public static void main(String[] args) {
        Thread t2 = new Thread(()->{
            while(true) {
                if(Thread.currentThread().isInterrupted()) {
                    System.out.println(x);
                    break;
                }
            }
        },"t2");
        t2.start();
        new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            x = 10;
            t2.interrupt();
        },"t1").start();
        while(!t2.isInterrupted()) {
            Thread.yield();
        }
        System.out.println(x);
    }

    对变量默认值(0,false,null)的写,对其它线程对该变量的读可见
    具有传递性,如果 x hb-> y 并且 y hb-> z 那么有 x hb-> z

    注意:变量都是指成员变量或静态成员变量

  • 相关阅读:
    find命令之xargs
    find命令之exec
    find 命令概览
    mv命令
    locate 命令
    whereis 命令
    linux which 查看可执行文件的位置
    Linux应用总结:自动删除n天前日志
    Visual Studio
    Visual Studio- “无法启动此程序,因为计算机中丢失 xxx.dll尝试重新安装该程序以解决此问题"
  • 原文地址:https://www.cnblogs.com/sglx/p/15266869.html
Copyright © 2020-2023  润新知