java虚拟机学习

java虚拟机，也就是我们通常叫的JVM。为什么我们要了解java虚拟机呢？总结起来有三点：
1：写出更好更健壮的java程序
2：提高java应用的性能，排除问题
3：面试（最实际的问题😄）
--------------------------------------这是分割线--------------------------------------

JVM运行的时候会把它管理的内存划分为不同的数据区。如图所示：

虚拟机内存分配图

其中编号为3，4，5的区域为线程私有的，线程私有意味着启动一个线程就会单独分配一块这样的区域，跟随线程产生和消亡 ，不需要过多考虑内存回收问题。剩余的1和2是共享区域。不管有多少线程，这些区域就只有一份。下面依次来解释这5个区域分别的作用：
（1）方法区：
作用：存放类信息，常量，静态变量以及即时编译期编译后的代码。
（2）堆：
作用：存放对象实例(几乎所有的对象)，数组
堆是用来存放对象的，无论是成员变量，局部变量还是类变量，它们指向的对象都存储在堆内存中。众所周知，一个对象的产生过程是用过new关键字实现的，但是在虚拟机内部却分成了大概5个步骤：检查加载—>分配内存—>内存空间初始化—>设置—>对象初始化。检查加载就是由类加载器加载到内存中；内存分配首先要检查有没有足够的内存进行分配，分为指针碰撞和空闲列表。如果是多线程的情况下，还要考虑并发安全问题。可以使用CAS机制或者本地线程分配缓冲(存在于栈帧中)；内存空间初始化就是一些变量，比如声明一个变量int i，如果不赋予初始值的话，就会默认的赋值0，就是在这一步之中实现的；设置主要就是在对象头中设置一些类的属性，比如类的HashCode，年龄信息，属于哪个类，锁信息等等；最后就是真正的初始化。

访问对象方式
上图展示的是两种对象的访问方式。左边为句柄池方式，右边为直接引用。直接引用缺少了中间的句柄池，所以直接引用的方式访问的速度更快。而句柄池的方便之处在于方便垃圾回收。假设右边的对象实例数据被回收了，直接操作句柄池就可以了，而不用改动引用。
我们都知道对象是分配在堆内存中的，那么是不是所有的对象都分配在堆中呢？显然不是，如果是的话上面的括号中也不用标注是几乎所有。 其实有时候对象是可以在栈上面分配的。这是因为虚拟机为了提升执行速度，使用了“逃逸分析技术”。逃逸分析技术是一种优化技术，而不是直接的优化手段。只是为了其他的优化手段提供依据的分析技术。逃逸分析技术的基本行为是分析对象的动态作用域。牵涉的JVM参数如下：

-XX:+DoEscapeAnalysis 启用逃逸分析。默认是打开的。冒号后面换成-号，则是关闭
-XX:+ElininateAllocations 标量替换。默认是打开的。冒号后面换成-号，则是关闭
-XX:+UseTLAB 本地线程分配缓冲。默认是打开的。冒号后面换成-号，则是关闭
-XX:+UseTLAB需要是开启的，然后会在栈帧中分配一个缓冲区域，不然对象是没有地方可以分配。否则的话即使-XX:+DoEscapeAnalysis是打开的也没有用。另外-XX:+ElininateAllocations也是需要打开的，不然同样无效。

public void test(){
  User user = new User();
  user.setName("jack")
}

所谓逃逸分析就是在方法中的，也就是上面例子中的user对象，如果在这个方法的外面没有使用到，也就是对象在这个方法的作用域之内，就会使用逃逸分析，会在栈中的分配缓冲区域中存储。但是只会存放一个，即时你使用for循环去生成很多个。可以预见的是如果没有这项优化技术，循环生成N多个对象需要频繁的进行GC，而使用了逃逸分析之后就不需要GC了，因为此时的对象是在栈当中，而栈又是属于线形私有的，那么线程死亡了，所有的就都消失了。
（3）虚拟机栈：
作用：存储当前线程运行方法所需要的数据(八种基本类型以及对象的引用 )，指令以及返回地址
了解虚拟机栈之前需要先了解一下栈（stack）。栈是一种数据结构，出口和入口只有一个，特点是先进后出。可以想象成一个水杯（假设水是不流动的）。往杯子里倒水的行为叫入栈，从杯子里往外倒水则叫出栈。肯定最先倒入水杯的水会被压在最下面，那么往外倒水的时候，最先入栈的肯定最后出栈。

public void A(){
        System.out.println("A方法执行之前");
        B();
        System.out.println("A方法执行之后");
    }

    public void B(){
        System.out.println("B方法执行之前");
        C();
        System.out.println("B方法执行之后");
    }

    public void C(){
        System.out.println("C方法执行之前");
        // do something
        System.out.println("C方法执行之后");
    }
// 输出结果
A方法执行之前
B方法执行之前
C方法执行之前
C方法执行之后
B方法执行之后
A方法执行之后

可以看到A方法最先入栈，却最后出栈。这也符合了栈的特点。这也解释了为什么叫虚拟机栈。
在虚拟机栈中，每一个方法在执行的同时都会创建一个“栈帧”。 栈帧可以划分为：局部变量表，操作数栈，动态连接，返回地址等等。

// 一个普通的类
public class Test {
    public static void main(String[] args) {
        Test test = new Test();
        int index = 0;
        test.helper(index);
    }

    private void helper(int index) {
        String str = "hello";
        System.out.print(str + index);
    }
}

// 这是反编译之后的部分代码
{
  public com.mzw.myrouter.Test();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 4: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/mzw/myrouter/Test;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=3, args_size=1
         0: new           #2                  // class com/mzw/myrouter/Test
         3: dup
         4: invokespecial #3                  // Method "<init>":()V
         7: astore_1
         8: iconst_0
         9: istore_2
        10: aload_1
        11: iload_2
        12: invokespecial #4                  // Method helper:(I)V
        15: return
      LineNumberTable:
        line 7: 0
        line 8: 8
        line 9: 10
        line 10: 15
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      16     0  args   [Ljava/lang/String;
            8       8     1  test   Lcom/mzw/myrouter/Test;
           10       6     2 index   I
}
SourceFile: "Test.java"

虚拟机栈分配

图中右侧的行号为0的操作是new，对应的就是Test test = new Test()这一行代码。总之所有的代码会按照上面的行号0，3，4，7等等来不断的进行入栈出栈直到走完方法。图中的返回地址对应的就是行号15处的return。本地局部变量表则对应的就是方法的参数args，index。动态连接则是对应的多态。
（4）本地方法栈：
作用：保存native方法的信息
当JVM的线程调用的native方法后，JVM不再为其在虚拟机栈当中创建栈帧，JVM只是简单的动态连接并直接调用native方法。
（5）程序计数器：
作用：指向当前线程正在执行的字节码指令的地址或者行号。

// 线程A
    public void inc(int i){
        i++;
        System.out.print(i);
    }

    // 线程B
    public void dec(int i){
        i--;
        System.out.print(i);
    }

假设上面的代码分别跑在两个不同的线程A和线程B。我们都知道线程能够执行是需要获取到CPU执行时间片才能够运行方法。还需要知道的一点就是++操作需要分三步：首先获取i的值，然后进行+1操作，最后把值重新赋给i。--操作也是如此。假设线程A刚获取到了i的值的时刻，线程切换了，线程B开始执行并执行了减1操作，随后又切换到线程A了。假如没有程序计数器的话，线程A是无法知道自己在切换到线程B之前执行到了三步中的哪一步的，那么切回来的时候，就无法进行下一步了，因为线程A不知道自己执行到哪一步了。所以程序计数器的作用就是确保多线程情况下程序的正常执行。