面试官：别的我不管，这个JVM虚拟机内存模型你必须知道

前言

说jvm的内存模型前先了解一下物理计算机的内存处理。

物理计算器上用户磁盘和cpu的交互，由于cpu读写速度速度远远大于磁盘的读写速度速度，所以有了内存（高速缓存区）。但是随着cpu的发展，内存的读写也跟不上cpu的读写速度了，cpu的产商就给每个cpu加入了一个高速缓存，也就是下面的结构。

JVM组成解析

1. 运行时数据区
   
   运行时数据区中包括：栈、堆、方法区（元空间）、本地方法栈、程序计数器。详细概念在之后会有记录。
2. 类装载子系统
   
   将字节码文件加载进运行时数据区。
3. 字节码执行引擎

栈和栈帧

在Java中，每开启一个线程，虚拟机就会为其分配一个栈空间和一个程序计数器，栈空间内又包含这个线程所要执行的每个方法对应的栈帧。

先来看一段简单的代码：

public class StackDemo {
	public static void main(String[] args) {
	        StackDemo sd = new StackDemo();
	        int number = sd.compute();
	        System.out.println("计算之后结果是："+number);
	    }

	    public int compute(){
	        int a = 1;
	        int b = 2;
	        int c = (a + b) * 10;
	        return c;
	    }
}

对生成的class文件进行反编译，生成对应的JVM指令码：

使用javap -c StackDemo.class命令，表示将这个class文件反编译并将反编译，并直接输出指令码到控制台。

public class com.jdc.demo.StackDemo {
  public com.jdc.demo.StackDemo();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class com/jdc/demo/StackDemo
       3: dup
       4: invokespecial #3                  // Method "<init>":()V
       7: astore_1
       8: aload_1
       9: invokevirtual #4                  // Method compute:()I
      12: istore_2
      13: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
      16: new           #6                  // class java/lang/StringBuilder
      19: dup
      20: invokespecial #7                  // Method java/lang/StringBuilder."<init>":()V
      23: ldc           #8                  // String 计算之后结果是：
      25: invokevirtual #9                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      28: iload_2
      29: invokevirtual #10                 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
      32: invokevirtual #11                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      35: invokevirtual #12                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      38: return

  public int compute();
    Code:
       0: iconst_1 //将int类型的常量1压入到操作数栈中。
       1: istore_1 //将int类型值 存入到局部变量1 这里指的是a
       2: iconst_2 //将int类型的常量2压入到操作数栈中。
       3: istore_2 //将int类型值 存入到局部变量2 这里指的是b
       4: iload_1 //从局部变量1中装载int类型值入栈。
       5: iload_2 //从局部变量2中装载int类型值入栈。
       6: iadd //将栈顶的两个int类型数相加，结果重新入栈。
       7: bipush        10 //往栈中压入10
       9: imul //将栈顶的两个int类型数相乘，结果重新入栈。
      10: istore_3 //将int类型值 存入到局部变量3 这里指的是c
      11: iload_3 //从局部变量3(c)中装载int类型值入栈。(是为了return)
      12: ireturn //返回
}

不难看出这一段中就是我们刚才写的简单的StackDemo类，可以通过查Oracle官方提供的指令码解析。网上也有很多。这里我已将compute()方法用到的指令意思标明到注解中。

看一下compute()方法的注释中的执行过程。

再来结合图看看执行过程：

    栈的数据结构：FILO
   上述图中main线程中有两个方法，main()方法和一个负责计算数字的compute()方法，具体执行过程如下：

1. main线程启动之后，先执行main()方法，执行main()方法的时候给它在栈空间中开辟出一块新的空间（栈帧）。
2. main()方法内部的局部变量的创建就是在这个栈帧中存放。但是要注意的是这里的局部变量是对象的话，它的值并不是存放在局部变量表中，而是在堆中存放具体，这里指向堆中对应的地址，之前第一节的图一中可以看出，栈中有很多指向堆的对象引用。
3. 等main()方法执行到调用compute()方法的那一步，线程调起compute()方法这时候compute()方法进栈，同样为它分配一块栈帧存放它自己的局部变量。
4. 等这个compute()方法执行完成自己的逻辑，就退出整个栈compute()方法出栈
5. 这个时候返回并继续执行main()方法中接下来的操作。

局部变量表

如上节图中以及执行过程中可以看出，局部变量表和操作数栈配合完成对数据处理的操作。

比如int a=1，

在指令码中分为三步：

• 把这个1就是先放入操作数栈，
• 同时给a这个变量在局部变量表中申请了一小块地方来存放。
• 然后将1从操作数出栈，并赋值给局部变量表中的a，完成赋值操作。

操作数栈

如栈那一节图中以及执行过程中可以看出，局部变量表和操作数栈配合完成对数据处理的操作。

比如int a=1，

在指令码中分为三步：

• 把这个1就是先放入操作数栈，
• 同时给a这个变量在局部变量表中申请了一小块地方来存放。
• 然后将1从操作数出栈，并赋值给局部变量表中的a，完成赋值操作。

动态链接

动态链接：方法是存放在方法区中的，方法加载到方法区的对应的入口内存地址（其他方法调用的时候）通过动态链接就可以很方便的知道对应方法的代码在方法区内的地址。

方法出口

compute()方法执行完之后返回到main()方法中，这个时候继续从main()方法中调用compute()方法的下一句开始执行，而不是重新从main()方法的第一句开始执行，这个就是方法出口。

程序计数器

程序计数器，很简单但是又很重要的一个设计。

每个线程开启都会有一个程序计数器，如上和栈帧章节中生成的jvm指令码，最左边有数字0 1 2…，这个值就是给程序计数器的。

为什么要设计程序计数器？

程序计数器作用：因为Java是多线程执行，所以就存在线程优先级高低之分，如果在这个线程执行过程中，有一个优先级更高的线程过来抢占CPU资源，等优先级高的那个线程执行完成之后，再将CPU资源还给当前线程，当前线程就是通过程序计数器才能知道目前它执行到哪一步。

堆内存

堆内存是最重要也是最复杂的一部分，这里面不仅要负责创建新的对象，还要负责gc，判断一个系统性能的重要指标之一就是程序员对堆内存的管理。因为大部分的JVM调优都会提到堆内存。

先介绍一下堆内存的构成：

1.创建对象都会放在年轻代的Eden区，当Eden区对象放满之后，这时候虚拟机会进行gc，但是这里的gc并不是full gc，而是minor gc，就是只清理年轻代的对象，而不管老年区的对象，这时候就要提一下GCRoots根节点（线程栈中的本地变量，静态变量，本地方法栈的变量等），当需要进行gc之前，jvm会根据Eden中的每一个GCRoots根节点去找它底下的引用，一层一层往下找，直到找到最后一个对象没有其他引用，这时候虚拟机会将这整个过程中的所有对象看做是非垃圾对象。

2.在gc的时候会将这些非垃圾对象赋值到S1区，然后将Eden区中剩余的没有引用的垃圾对象清理，清理完成之后，Eden区空出来了，有用的对象现在都存放在S1中，然后将S1和S2替换（之前是Eden和S1配合，目下一次的gc就是Eden和S2配合）。第二次进行gc的时候，会对Eden区和刚才的S1区进行和第一次gc同样的操作…每次gc之后，活下来的对象年龄会+1，进行一定次数的gc之后，也就是说这个幸存者对象年龄达到足够大，这时候虚拟机会将它放入老年代。------->使用java自带工具查看jvisualvm

3.当老年区装满之后，jvm会进行一次非常耗时的full gc，这个时候程序整个是没办法继续进行的，当full gc完了之后，如果顺利，程序将继续执行，只是性能上有一些损耗，因为常说的jvm调优说白了就是减少gc次数和减少每次gc时间（可以设置初始堆大小。。。等等），如果目前老年代中的对象还都是非垃圾对象，那么就会出现OOM内存溢出。

这里提一下jvm的垃圾回收算法

垃圾回收算法有四种，一一介绍一下：

1、标记-清除：最基础的也是最简单，最容易实现的一种算法，分为两阶段，第一阶段标记已经没有引用的对象（垃圾），第二阶段清除。

优点：方便。

缺点：产生内存碎片，因为你并不知道一块儿内存上边哪里的是垃圾，哪里的是非垃圾，所以清理完之后会存在很多内存碎片。

2、复制算法：是目前新生代还在使用的方法，但是现在的使用时经过优化的（8:1:1）。它的实现是将一块内存分成大小相同的两块，每次使用一块，当这块内存满了的时候，将它上边还存活的对象移动到另一块内存上。。。循环使用。

缺点：内存使用不充分，花了100块钱，却只能享受50块钱的服务。

3、标记-整理：这种算法和第一种标记清除差不多，都是第一阶段先对垃圾对象进行标记，但是标记整理的第二阶段不是立即清理，而是先将存活的对象向一边移动，然后最后清理掉垃圾对象那边的内存。

4、分代收集：目前jvm使用最多，大概就是对新生代使用复制算法，而对老年区采用的是标记整理算法。因为新生代时时刻刻都在产生对象，所以非常容易满，这也就以为着它需要经常进行清理，所以采用复制算法，但它的复制算法不是讲内存分成1:1的两块，而是默认分为8:1:1

可以通过java自带的jvisualvm来看一下内存的变化

这里只附上一张图，因为它上边的监控都是动态变化的，而且理论上边也已经记录清除，有兴趣的小伙伴可以自己去试试。

代码：

public class Test{

    public static void main(String[] args) throws Exception {
        List<Test> list = new ArrayList<Test>();
        //死循环，让一直创建对象，并且都是有引用对象
        while (true){
            list.add(new Test());
            Thread.sleep(10);
        }
    }
}

win+R—>cmd—>jvisualvm

上图：

提一下关于jvm调优

STW：stop the word 意思就是在gc的时候，程序线程是暂停的，这个时候就看垃圾多不多了，如果多的话，gc要执行的时间就长，这个时候用户的体验就会非常差。

jvm调优：减少STW次数和时间，但是STW是必须得要的，这是java的设计机制。和程序计数器一样，非常巧妙。

原因：可以从本文第一张图看到，拿栈和堆来举例子，栈中的方法有关于对象的引用，而这个引用正是指向堆中的，当gc的时候是通过这个GCRoots根来一步一步找到堆，然后再从堆中找下一个引用，比如一个项目中，对象是在不断创建（电商项目中搞活动大促销抢东西的前几秒），这中时候，一秒钟创建的对象可能是几十MB的，再加上关联的订单对象创建、购物车、等等一系列。如果这个时候我gc一次，gc是需要时间的，它的时间和STW时间一样，但是如果没有STW，我在这次gc开始前，还有成千上万个对象正在创建的过程中（这个时候它们有引用，比如创建的订单对象依赖购物车对象），这个时候gc完成了，会将线程中栈中的方法栈帧释放掉，释放掉栈帧之后，自然就没有方法的局部变量表了，又因为我开始就是通过局部变量表中的某个对象作为GCRoots根往下找引用的，如果没有STW时间，在gc执行完之后我这个对象本来不是垃圾，但是它现在的GCRoots根的没有了，自然没有了引用，这个时候我这个对象就成为了垃圾，还没用就成了垃圾，那程序肯定就会GG。。。

方法区

主要存放的是常量、静态变量以及类信息。

本地方法栈

执行非java本地代码（native关键字）的方法。

最后

感谢你看到这里，文章有什么不足还请指正，觉得文章对你有帮助的话记得给我点个赞，每天都会分享java相关技术文章或行业资讯，欢迎大家关注和转发文章！