【Kill Thread Part.2-1】Java内存模型——底层原理

一、什么是“底层原理”？本章研究的内容？

1、从Java代码到CPU指令

• 从.java文件到.class文件，然后JVM翻译成对应操作系统平台的机器指令。
• JVM实现会带来不同的“翻译”，不同的CPU平台的机器指令又千差万别，无法保证并发安全的效果一致。
• 重点开始向下转移：转化过程的规范、原则

2、JVM内存结构 VS Java内存模型 VS Java对象模型

①整体方向

• JVM内存结构：和Java虚拟机的运行时区域有关
• Java内存模型：和Java的并发编程有关
• Java对象模型：和Java对象在虚拟机中的表现形式有关

②JVM内存结构

③Java对象模型

Java是面向对象的语言，每一个Java对象在JVM中存储是有一定的结构的。

• Java对象自身的存储模型

• JVM会给这个类创建一个instanceKlass，保存在方法区，用来在JVM层展示该Java类。

• 当我们在Java代码中，使用new创建一个对象的时候，JVM会创建一个instanceOopDesc对象，这个对象中包含了对象头以及实例数据。

④Jav内存模型是什么？

下面详细介绍

二、JMM是什么(Java Memory Model)

• 是规范
  • C语言不存在内存模型的概念
    • 依赖处理器，不同处理器结果不一样
    • 无法保证并发安全
  • 需要一个标准，让多线程运行的结果可预期
  • 是一组规范，需要各个JVM的实现来遵守JMM的规范，以便于开发者可以利用这些规范，更方便地开发多线程程序。
    • 如果没有这样一个内存模型来规范，那么很可能经过了JVM的不同规则的重排序之后，导致不同的虚拟机上运行的结果不一样，造成很大的问题。
• 是工具类和关键字的原理
  • volatile、synchronized、Lock等的原理都是JMM
  • 如果没有JMM，那就需要我们自己指定什么时候用内存栅栏等，那是相当麻烦的，幸好有了JMM，让我们只需要用同步工具和关键字就可以开发并发程序。
• 最重要的三点内容：重排序、可见性、原子性

三、重排序

1、案例演示：什么是重排序？

①测试代码

/**
 * 描述： 演示重排序的现象“直到达到某个条件才停止”，测试小概率事件
 */
public class OutOfOrderExecution {
    private static int x = 0, y = 0;
    private static int a = 0, b = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread one = new Thread(new Runnable() {
            @Override
            public void run() {
                a = 1;
                x = b;
            }
        });
        Thread two = new Thread(new Runnable() {
            @Override
            public void run() {
                b = 1;
                y = a;
            }
        });
        one.start();
        two.start();
        one.join();
        two.join();
        System.out.println("x = " + x + "," + "y = " + y);
    }
}

运行结果：

②重排序分析

这4行代码的执行顺序决定了 最终x和y的结果，一共有3种情况：

• 虽然代码执行顺序可能有多种情况，但是在线程1的内部，也就是：a = 1; x = b；

  • 这两行代码的额执行顺序，是不会改变的，也就是a = 1,会在x = b，前执行；同理，线程2的b = 1会在y = a前执行。

• 出现(0, 0)的诡异情况

  • 测试代码：

    • /**
       * 描述：     演示重排序的现象 “直到达到某个条件才停止”，测试小概率事件
       */
      public class OutOfOrderExecution {
      
          private static int x = 0, y = 0;
          private static int a = 0, b = 0;
      
          public static void main(String[] args) throws InterruptedException {
              int i = 0;
              for (; ; ) {
                  i++;
                  x = 0;
                  y = 0;
                  a = 0;
                  b = 0;
      
                  CountDownLatch latch = new CountDownLatch(3);
      
                  Thread one = new Thread(new Runnable() {
                      @Override
                      public void run() {
                          try {
                              latch.countDown();
                              latch.await();
                          } catch (InterruptedException e) {
                              e.printStackTrace();
                          }
                          a = 1;
                          x = b;
                      }
                  });
                  Thread two = new Thread(new Runnable() {
                      @Override
                      public void run() {
                          try {
                              latch.countDown();
                              latch.await();
                          } catch (InterruptedException e) {
                              e.printStackTrace();
                          }
                          b = 1;
                          y = a;
                      }
                  });
                  two.start();
                  one.start();
                  latch.countDown();
                  one.join();
                  two.join();
      
                  String result = "第" + i + "次（" + x + "," + y + ")";
                  if (x == 0 && y == 0) {
                      System.out.println(result);
                      break;
                  } else {
                      System.out.println(result);
                  }
              }
          }
      }
      

    • 

③为什么会出现(0, 0)的情况？

会出现x = 0,y =0？那是因为重排序发生了，四行代码的执行顺序的其中一种可能。

什么是重排序：

在线程1内部的两行代码的实际执行顺序和代码在Java文件中的顺序不一致，代码指令并不是严格的按照代码语句顺序执行的，它们的顺序被改变了，这就是重排序，这里被颠倒的时y = a和b = 1这两行语句。

2、重排序的好处：提高处理速度

①重排序前的指令

②重排序后的指令

可以看到指令数变少了，这样执行速度就会变快。

3、重排序的优化

编译器优化：包括JVM，JIT编译器等

CPU指令重排：就算编译器不发生重排，CPU也可能对指令进行重排

内存的“重排序”：线程A的修改线程B却看不到，引出可见性问题（主存和缓存的问题）

四、可见性

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();
        }
    }
}

②可能出现的结果

这三种情况可能是多线程执行顺序导致的，

但是，还有一种情况，是内存的可见性问题导致的。

③详细分析

两个线程是不能直接通信的，只有通过访问主存。一个写，一个读。

2、用volatile解决问题

将上述案例演示代码的a, b的值前面加上volatile，就不会出现可见性的问题了。

原理

3、为什么会有可见性问题

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

4、JMM的抽象：主内存和本地内存

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

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

主内存和本地内存的关系

JMM有以下规定：

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

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

五、Happens-Before原则

1、什么是happens-before

• happens-before规则是用来解决可见性问题的：
  • 在时间上，动作A发生在动作B之前，B保证能看见A，这就是happens-before.
• 两个操作可以用happens-before来确定它们的执行顺序：
  • 如果一个操作happens-before于另一个操作，那么我们说第一个操作对于第二个操作是可见的

2、什么不是happens-before

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

3、原则有哪些？

• 单线程规则
  • 如果是单线程，后面的代码一定可以看见前面代码的操作。
    • 因为每个线程都有自己的工作内存
    • 但是有可能发生重排序。
• 锁操作
  • 
  • 
    • 假设A拿到了锁，执行完ynchronized代码块之后释放锁，然后B拿到锁，是可以看到A的所有操作的。
• volatile变量
  • 只要写入了，读取的线程一定可以读取到volatile修饰的变量。
• 线程启动
  • 
• 线程join
  • 子线程join，主线程join下面的语句都能看到join的子线程的所有操作。
• 传递性
  • 如果hb(A, B)而且hb(B，C)，那么可以推出hb(A，C)
• 中断
  • 一个线程被其他线程interrupt，那么检测中断isInterrupted或者抛出InterruptedException一定能看到
• 构造方法
  • 对象构造方法的最后一行指令happedns-before与finalize()方法的第一行指令
• 工具类的happens-before原则
  • 线程安全的容器get一定能看到再次之前的put等存入动作
  • CountDownLatch
  • Semaphore
  • Future
  • 线程池
  • CyclicBarrier