JVM常见面试题汇总笔记

第一章：JVM虚拟机的介绍

1.1虚拟机的分类

虚拟机通常分为两类：系统虚拟机和程序虚拟机。其中，系统虚拟机是指完全对物理计算机的仿真，而程序虚拟机是指专门为执行单个计算机程序而设计的的。我们的java虚拟机就是典型的程序虚拟机。

1.2Java虚拟机的整体架构

1.3 Java代码的执行流程

1.4 Java的架构模型

java编译器输入的指令流基本上是一种基于栈的指令集架构,另外一种指令集架构则是基于寄存器的指令集架构。

具体来说，两种架构的区别是：

• 1.基于栈式架构的特点：
  设计和实现更简单，适用于资源受限的系统;
  避开了寄存器的分配难题，使用零地址指令方式分配;
  指令流中的指令大部分是零地址指令，其执行过程依赖于操作栈。指令集小，编译器容易实现;
  不需要硬件支持，可移植性更好，更好实现跨平台;
• 2.基于寄存器架构的特点:
  典型的应用是×86的二进制指令集;
  指令集架构则完全依赖硬件,可移植性差;
  花费更少的指令完成一些操作;
  性能优秀,执行更高效;

1.5 Java的生命周期

1.虚拟机的启动

通过引导类加载器BootStrap Class Loader 来创建一个初始类(initial class)来完成

2.虚拟机的执行

当程序开始执行的时候，java虚拟机就开始执行

当程序执行结束的时候，java虚拟机执行结束(停止运行)

注意：

• 执行java程序的时候，其实真正的是执行一个java虚拟机进程的过程

3.虚拟机退出的情况：

1）程序的正常执行结束

2）程序在执行过程中遇到了异常或者是错误而异常(错误)终止

3）由于操作系统出现了错误而导致了JVM进程终止

4）某线程调用了Runtime类/System类的exit方法或者Runtime类的halt方法，并且java安全管理器允许这次exit和halt操作

5）JNI规范中用JNI API加载和卸载了Java虚拟机时，java虚拟机退出

1.6 JVM的发展历程(重点几个JVM)

• Sun Classic VM JDK1.4被完全淘汰
• HotSpot VM java的默认虚拟机
• BEA JRockit
• IBM J9

第二章 类加载子系统篇章

2.1 类加载子系统的相关概念

注意以下几点:

1.class文件在文件的开头有特定的文件标识

2.ClassLoader只负责class文件的加载，至于它是否可以运行，由Execution Engine(执行引擎)来决定

3.加载的类信息存放在于一块叫做方法区的内存空间里面

类的加载过程

1. 加载(Loading)过程：生成Class实例

过程
1.通过一个类的全限定名获取定义此类的二进制字节流
2.将这个字节流所代表的静态存储结构转换成方法区的运行时数据结构
3.在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口

加载class文件的方式有：

1）从本地系统直接加载

2）网络获取

3）ZIP压缩包获取

4）动态代理技术获取

5）其他技术获取，例如从专有的数据库获取，从加密文件中获取等等

2. Linking过程:

2.1 验证(Verify)

确保class文件的字节流中包含信息是否符合虚拟机的规划要求(CAFE BABY开头)，保证被加载的类的正确性;

主要包括：文件格式验证，元数据验证，字节码验证，符号引用的验证等等;

2.2准备(Prepare)

为类变量(即静态变量)分配内存并且设置该类变量的默认初始化值,也就是我们所说的零值;

注意：这里不包含用final修饰的类变量值。因为final修饰的常量在编译的时候已经分配好了，准备阶段会进行显式的初始化；同时，这里也不会为实例变量进行分配初始化，类变量会分配到方法区中（jdk7以后分配到堆区，在后面有进一步的讲解），而实例变量是会随着对象一起分配到Java堆中的。

2.3.解析(Resove)

将常量池中的符号引用转换成直接引用的过程

其中，符号引用指的是一组符号锁引用的目标。符号引用的字面量形式明确规定在Class文件格式中;

而直接引用就是直接指向目标的的指针，相对偏移量或者一个间接定位到目标的句柄。

3.初始化阶段(Initalization)

初始化阶段就是执行类构造器的clinit()方法

此方法无需进行定义，是javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中语句合并而来的(言外之意就是如果该类没有定义静态变量和静态代码块的话，此方法将不会在jvm类加载中执行)

如果该类具有父类，JVM会保证子类的clinit()方法执行前，父类的clinit()方法已经执行完毕;

虚拟机必须保证一个类的clinit方法在多线程下被同步加锁-----只会加载一次! ! !

2.2 类加载器的分类

JVM支持两种类型的类加载器 :

• 引导类加载器(BootStrap CLassLoader)

• 自定义类加载器(User-Defined CLassLoader)

注意:此处将所有的派生于抽象类CLassLoader类加载器都划分为自定义类加载器，其中扩展类加载器(Extension ClassLoader)和系统类加载器(System CLassLoader)都属于CLassLoader类加载器，故他们都属于自定义类加载器。

具体分析三种类加载器：

1.启动类加载器(引导类加载器,BootStrap ClassLoader)

这个类加载器是使用C/C++语言实现的,嵌套在JVM的内部

它是用来加载Java的核心库(JAVA_HOME/jre/rt.jar,resoures.jar或者sun.boot.class.path路径下的内容)，用来提供JVM自身需要的类。

它并不继承java.lang.CLassLoader,没有父类加载器

加载扩展类和应用类加载器，并制定为他们的父类加载器

出于安全考虑，BootStrap启动类加载器只加载包名为java,javax.sun等开头的类

代码测试:

public class ClassLoaderTest {
    public static void main(String[] args) {
		
        //获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //获取其上层：扩展类加载器
        ClassLoader extClassLoader = systemClassLoader.getParent();
        System.out.println(extClassLoader);//sun.misc.Launcher$ExtClassLoader@1540e19d

        //获取其上层：获取不到引导类加载器
        ClassLoader bootstrapClassLoader = extClassLoader.getParent();
        System.out.println(bootstrapClassLoader);//null

        //对于用户自定义类来说：默认使用系统类加载器进行加载
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //String类使用引导类加载器进行加载的。---> Java的核心类库都是使用引导类加载器进行加载的。
        ClassLoader classLoader1 = String.class.getClassLoader();
        System.out.println(classLoader1);//null
    }
}

输出打印:

sun.misc.Launcher$AppClassLoader@18b4aac2  //系统类加载器
sun.misc.Launcher$ExtClassLoader@1b6d3586  //扩展类加载器
null  //引导类加载器:因为不在jvm中定义,底层是c/c++实现,则返回null
sun.misc.Launcher$AppClassLoader@18b4aac2//用户自定义类使用系统类加载器加载
null//String类时用引导类直接加载的

2.扩展类加载器(Extension CLassLoader)

java语言编写,由sun.misc.Launcher$ExtClassLoader实现；

派生于ClassLoader类；

父类加载器为启动类加载器(引导类加载器)；

从java.ext.dirs系统属性所指定的目录中加载类库，或者从JDK的安装目录的jre/lib/ext子目录(扩展目录)下加载类库。如果用户创建的JAR放在此目录下,也会自动使用扩展类加载器加载；

3.系统类加载器(System CLassLoader,或者称为应用类加载器)

java语言编写，由sun.misc.LauncherAppClassLoader实现；

父类为扩展类加载器

它只负责加载环境变量classpath或者系统属性java.class.path指定路径下 的类库;

该类加载是程序默认的类加载器,一般来说，Java应用的类都是由它来完成加载的；

通过ClassLoader.getSystemClassLoader()方法可以获得该类加载器；

为什么要自定义类加载器呢?

• 隔离加载类

• 修改类加载的方式

• 扩展加载源

• 防止源码的泄露

获取ClassLoader的途径:

☆面试题:双亲委派机制

Java虚拟机对class文件采用的是按需加载的方式,也就是说当需要使用该类时才会将它的class文件加载到内存中生成class对象,而且加载某个类的class文件时,Java虚拟机采用的是双亲委派模式,即把请求交由父类处理,它是一种任务委派模式.

双亲委派机制的优点:

1.避免类的重复加载

2.保护程序的安全性,防止核心API随意被篡改

沙箱安全机制:保证对Java信息源代码的保护

何为沙箱安全机制?即如果我们自己建立和源代码相同的包,例如java/lang/String.Class,在我们去使用类加载器去加载此类时,为了防止你自定义的类对源码的破坏,所以他默认不是使用你的String类的本身的系统加载器去加载它,而是选择率先使用引导类加载器去加载,而引导类在加载的过程中会先去加载JDK自带的文件(rt.jar包中的java/lang/String.class),而不是你自己定义的String.class,报错信息会提示没有main方法 ,就是因为加载的是rt.jar包下的String类,这样就可以做到保证对java核心源代码的保护,这即是沙箱保护机制.

2.3 类加载器的其他问题

1. JVM判断两个class对象是否为同一个类存在两个必要条件:

1)类的完整类名必须一致(包括包名)		
2)加载类的ClassLoader必须相同

2. 若是一个类型由用户加载器(系统加载器)加载,那么JVM会将这个类加载器的一个引用类型信息的一部分保存到方法区中.

3. 类的主动使用和被动使用

主动使用情况:

① 创建类的实例

②访问某个类或者接口的静态变量

③调用类的静态方法

④反射

⑤初始化一个类的子类

⑥Java虚拟机启动时被表明启动类的类等等

被动使用:若使用类不会导致类的初始化,则为被动使用

第三章 运行时数据区概述及其过程

运行时数据区(Runtime Dat Area):即为JVM的内存空间,当然,不同的JVM虚拟机对于运行时数据区的划分会有部分的差别.

详细图如下所示(阿里出品,JDK8及以后版本):

每一个JVM只有一个Runtime实例,即运行时环境;

对于线程(即一个程序的运行单元,进程的组成单元)来说.JVM允许一个应用程序有多个线程并行(基于多核CPU或者CPU多核心来说)地执行;

HotSpot VM中,每一个线程都与操作系统的的本地线程直接映射,即当一个java线程准备好执行以后,此时操作系统的一个本地线程也同时创建,其中,操作系统负责所有的线程的安排调度到任何一个可用的cpu上,一旦本地的线程初始化成功,它就会调用java线程中的run()方法.而当Java线程执行终止时,本地线程也会进行回收.

Java默认底层是基于HotSpot VM实现的，其中:

这里主要的后台系统线程在HotSpot JVM中里面主要有以下几种：

• 虚拟机线程：这些线程的操作是需要JVM达到安全点才会出现。这些操作必须在不同的线程中发生的原因是他们都需要JVM达到安全点，这样堆才不会变化。这种线程的执行类型包括“stop-the-world”的垃圾收集，线程栈收集，线程挂起以及偏向锁撤销。

• 周期任务线程：这种线程是时间周期事件的体现（比如中断），他们一般用于周期性的调度执行。

• GC线程：这种线程对在JVM里不同种类的垃圾收集行为提供了支持

• 编译线程：这种线程在运行时会将字节码编译到本地代码

• 信号调度线程：这种线程接收信号并发送给JVM，在他内部通过调用适当的方法进行处理

第四章 程序计数器(PC寄存器)

4.1 相关概念介绍

程序计数器:用来储存指向下一条指令的地址,也就是即将要执行的指令代码,由执行引擎来读取下一条指令.

程序计数器是一块很小的内存空间,但也是运行速度最快的存储区域

JVM规范中,每一个线程中都有属于自己的程序计数器,它是线程私有的,其生命周期和线程的生命周期保持一致

任何时候,一个线程中都只有一个方法在执行,即当前方法,程序计数器会存储当前线程正在执行的Java方法的JVM指令地址,如果执行native方法(本地方法),则是未指定值.

注意以下几点:

1.它是程序控制流的指示器,分支,跳转,异常处理,线程恢复等基础功能都需要依赖程序计数器来完成.

2.字节码解释器工作时就是通过程序计数器来选取下一条需要执行的字节码指令.

3.它是唯一一个在Java虚拟机规范中没有规定任何OOM(OutOfMemoryError),即内存溢出情况的区域

4.2常见面试问题

1. 为什么使用程序计数器来记录当前线程的执行地址?

解析:cpu需要不断进行各个线程之间的切换操作，当从一个线程从到另一个线程切换回来的时候,需要知道接下来从哪里开始继续执行，就是接下来执行指令的地址位置，而JVM的字节码解释器就需要通过不断地改变PC计数器的值来明确下一条应该执行什么样的字节码指令了。

2. PC计数器为什么要设置为线程私有的?

第一种回答：多线程在一个特定的时间段只会执行其中的某一个线程的方法，cpu会不停的进行任务的切换,这样必然会导致经常发生线程的中断和恢复工作，那么让其可以做到没有丝毫问题，就需要在每一个线程中设置自己的pc计数器，来记录各个线程自己正在执行的当前字节码指令地址，这样一来各个线程之间可以进行独立的计算，从而不会出现相互干扰的情况。

第二种回答：由于cpu时间片轮限制(时间片即是cpu分配给各个程序的时间,每个线程被分配的一个时间段,称作为它的时间片)，而当众多线程在并发执行过程中，任何一个确定的时刻，一个处理器或者多核处理器的一个内核，只会执行某一个线程中一条指令，这样会导致经常性的中断或者恢复，如何可以保证其分毫不差,则可以在每个线程创建以后，都会创建自己的程序计数器和栈帧，其程序计数器在各个线程中是相对独立，互不影响的。

第五章 Java虚拟机栈

5.1 虚拟机栈的概述

由于跨平台的设计,导致java的指令是基于栈设计(实现与各个操作系统的低耦合性,从而实现跨平台)。

优点：跨平台，指令集小，编译器容易实现。

缺点：性能下降，实现同样的功能需要更多的指令。

对比Java内存区中的栈和堆：

栈	堆
解决的是程序的运行问题,即程序如何执行,或者说如何处理数据	解决的是数据的存储问题,即数据怎么放,放在哪里

Java虚拟机栈定义：

Java Virtual Machine Stack：每个线程在创建时，都会伴随着创建一个虚拟机栈,其内部保存着一个个的栈帧(Stack Frame)，对应着一次次的Java方法的调用。即可以理解为栈的内部是由一个个的栈帧组成的，而一个java方法对应着一个栈帧。

它是线程所私有的。

生命周期和线程一致

作用：主管Java程序的运行，它保存方法的局部变量(即8种基本数据类型，如果是对象类型，只会保存对象的引用地址)，部分结果，并参与方法的调用和返回。

Java虚拟机栈的优点：

• 栈是一个快速有效的分配存储方式，访问速度仅次于程序计数器

• JVM直接对Java栈的操作只有两个：

  每个方法调用的时候，伴随着进栈(入栈,压栈)操作

  执行结束后，进行出栈操作

• 对于栈来说，不存在垃圾回收(GC)

面试题:开发中Java栈中经常出现的异常有哪些?

在Java虚拟机栈中，可能出现的异常有以下这些：

Java虚拟机规范中允许Java栈的大小是动态的或者是固定不变的。

• 如果采用固定大小的Java虚拟机栈，那么每一个线程的Java虚拟机栈容量可以在线程创建的时候独立选定。如果线程请求分配栈容量超过了Java虚拟机栈允许的最大容量，Java虚拟机将会抛出一个StackOverFlowError异常。
• 如果Java虚拟机栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的内存，或者是在创建新的线程的时候没有足够的内存去创建对应的虚拟机栈，此时Java虚拟机将会抛出一个OutOfMemoryError异常。

即栈会出现StackOverflowError和OutofMemoryErrory异常

5.2 栈的存储单位

每个线程都有自己的虚拟机栈,栈中数据都是以栈帧(Stack Frame)的格式存在的;

在这个线程上正在执行的每个方法都各自对应着一个栈帧;

栈帧是一个内存区块,是一个数据集,维系着方法执行过程中的各种数据信息;

栈运行的原理

• JVM直接对Java栈的操作只存在两个，就是对栈帧的压栈和出栈，遵循“先进后出”原则
• 在一条活动线程中，一个时间点上，只会存在一个活动的栈帧。即只有当前正在执行的方法的栈帧是有效的，这个栈帧被称为当前栈帧，与之对应的方法称为当前方法
• 执行引擎运行的所有的字节码指令只针对当前栈帧进行操作
• 如果当前方法调用了其他方法，对应的新的栈帧就会被创建出来，并放在栈的顶端，称为新的当前帧

注意以下几点:

1.不同线程中所包含的栈帧是不允许存在相互引用的,即不可能在一个栈帧之中引用另外一个线程的栈帧;

2.如果当前方法调用了其他方法,方法返回之际,当前栈帧会传入此方法的执行结果,给前一个栈帧,接着虚拟机栈会丢弃当前栈帧,使得前一个栈帧重新成为当前栈帧;

3.Java方法有两种返回函数的方式,一种是正常的函数返回,使用return指令;另一种是抛出异常;不管是哪种方式,都会导致栈帧被弹出.

5.3栈帧的内部结构

每一个栈帧中都存储着以下结构：

• 局部变量表（Local Variables）
• 操作数栈（Operand Stack）
• 动态链接
• 方法返回地址
• 一些附加信息

5.3 局部变量表(Local Variables)

局部变量表也被称为局部变量数组或者本地变量表

定义为一个数字数组，主要是因为其用来存储方法参数和定义在方法体内的局部变量，这些数据包括了各类的基本数据类型，对象引用，以及returnAddress类型；

由于局部变量表是建立在线程的栈上，是线程私有数据，因此不存在数据安全问题；

局部变量表所需的容量大小是在编译期就确定下来的，并保存在方法的Code属性的maxmum local variables数据项中。在方法运行期间不会改变局部变量表的大小

同时,请注意以下几点:

1. 方法嵌套调用的次数由栈的大小决定，一般来说,栈越大，方法嵌套调用的次数就越多.

2. 局部变量表中的变量只有在当前方法调用中有效。在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程，当方法调用结束后，随着方法的栈帧的销毁,局部变量表也会随之销毁。

Slot槽的概念

参数值的存放总是在局部变量数组的index0开始的,到数组长度-1的索引结束。

局部变量表，最基本的单位就是Slot(变量槽)

局部变量表中存放在编译期可知的各种基本数据类型(8种)，引用类型(reference)，returnAddress类型的变量;

在局部变量表里，32位以内的类型只会占用1个slot(包括returnAddress类型)，64位的类型(long和double)占用两个slot：

• byte,short,char在存储前被转换成int;
• boolean也会被转换成int,0表示false,非0表示true;
• long和double则占据了两个slot槽;

其中，JVM会为局部变量表中的每一个Slot都分配一个访问索引，通过这个索引即可以成功访问到局部变量表中指定的局部变量值。

当一个实例方法被调用的时候，它的方法参数和方法体内部定义的局部变量将会按照顺序被复制到局部变量表中的每一个Slot上。

如果需要访问局部变量表中的一个64bit的局部变量值时，只需要使用前一个索引即可（比如：访问long或者double类型的变量）

如果当前帧是由构造方法或者实例方法创建的，则该对象引用this将会存放在index为0的slot处，其余的参数按照参数表顺序继续排列

注意：因此静态方法中无法使用this变量的原因:局部变量表中没有存在this引用

**Slot的可重复利用性 : **

• 栈帧中的sot槽是可以重复利用的，如果一个局部变量过了作用域，那么在其作用域之后，申明一个新的局部变量会复用过期的局部变量的槽位。从而达到了节省资源的目的。

 public void test(){
     {
         int a = 0;
         System.out.println(a);
     }
     double b = 5;//此时b在局部变量表中会复用a的槽位,只不过会多增加一个
 }

细节知识点1：类变量表有两次初始化的机会。第一次是在"准备阶段"，执行系统的初始化，对类变量设置零值，另一次则是在"初始化"阶段，赋予程序员在代码中定义的初始值；但是局部变量不存在系统初始化的过程，这也意味着一旦定义局部变量表，则必须人为地进行初始化，否则无法正常使用。

public void test02(){
    int i;		//未人为初始化赋值,下面打印会出错
    System.out.println(i);
}

**细节知识点2：**局部变量表中的变量是重要的垃圾回收根节点(GC Roots)，只要被局部变量表直接或者间接引用的对象都不会被垃圾收集器回收！

5.4 操作数栈(Operand Stack)

每一个独立的栈帧除了包含局部变量表以外,还包含一个后进先出(Last-In-First-Out)的操作数栈,也可以称为表达式栈;

操作数栈：在方法执行过程中，根据字节码指令，往栈中写入数据或者提取数据，即入栈(push)/出栈(pop)

• 某些字节码指令将值压入操作数栈中，其余的字节码指令将操作数取出栈。使用他们后再将结果压入栈，比如：执行复制，交换，求和等操作

其中：

• 操作数栈，主要是用于保存计算过程中的中间结果，同时作为计算过程中变量临时存储空间

• 操作数栈就是JVM执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来，这个方法的操作数栈是空的

• 每个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译期就定义好了，保存在方法的Code属性中，为max_stack的值

• 栈中的任何一个元素都是可以任意的Java数据类型

  • 32bit的类型占用一个栈单位深度
  • 64bit的类型占用两个栈单位深度

• 操作数栈并非采用访问索引的方式进行数据访问的，而是只能通过标准的入栈和出栈操作来完成一次数据访问。

注意:

1. 如果被调用的方法带有方法值,其返回值将会被压入当前栈帧的操作数栈中,并更新pc寄存器下一条需要执行的字节码指令;

2. 操作数栈中元素的数据类型必须与字节码指令的序列严格匹配,这由编译器在编译期间进行验证,同时在类加载过程中的类检验阶段的数据流分析阶段要再次验证.

3. Java虚拟机栈的解释引擎是基于栈的执行引擎,其中的栈就是操作数栈.

5.5 栈顶缓存技术----牛逼

由于操作数栈是存储在内存中,因此频繁地进行内存的读与写的操作必然会影响执行的速度,为了解决这个问题,HotSpot VM使用了一种栈顶缓存技术:将栈顶元素全部缓存到物理cpu的寄存器中,以此降低对内存的读/写次数,从而提升执行引擎的执行效率.

5.6 动态链接(Dynamic Linking)

每一个栈帧内部都包含一个指向运行时常量池中该栈帧所属方法的引用.包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接(Dynamic Linking)

可以说:动态链接的作用就是将这些运行时常量池的符号引用转换成调用方法的直接引用

面试题:为什么存在常量池?

常量池的作用就是为了提供一些符号和常量,一方面便于指令的识别,也节省了内存的使用,若是直接将这些变量存入,将会大量占用内存空间.

5.7 方法的调用方式

在JVM中,将符号引用转换成调用方法的直接引用与方法的绑定机制有关

• 静态链接：当一个字节码文件被装载到JVM内部时，如果被调用的目标方法在编译器是可知的，且在运行期保持不变。这种情况下将调用方法的符号引用转成直接引用的过程称为静态链接
• 动态链接：如果被调用的方法在编译器无法确定下来，也就是说，只能够在程序运行期将调用方法的符号引用转成直接引用，由于这种引用转换过程具备动态性，因此也就被称为动态链接。

Java中任何一个方法都具备虚方法的特征！！

非虚方法：

• 如果方法在编译期就确定了具体的调用版本，且在运行时不可变,则这样的方法称为非虚方法。例如：静态方法，私有方法，final方法，实例的构造器方法，父类方法。

虚方法：

• 即是与非虚方法相反编译期不能确定了具体的调用版本，且运行时可能会发生变化

JVM中提供的方法调用指令:

方法名	作用
invokeStatic	调用静态方法(唯一确定)
invokeVirtual	调用init()方法,私有方法及父类方法等
invokeVirtual	调用所有虚方法
invokeinterface	调用接口方法
invokedynamic	动态解析出需要调用的方法,然后执行

前四条指令固化在虚拟机内部，方法的调用执行不可人为干预，而invokedynamic指令则支持用户确定版本；

所以我们可以说Java 语言中方法重写的本质：

1. 找到操作数栈顶的第一个元素所执行的对象的实际类型，记作C
2. 如果在类型C找到与常量中的描述符合简单名称都相符的方法，则进行访问权限的校验，如果通过则返回这个方法的直接引用，查找过程结束；如果不通过，则返回java.lang.IllegalAccessError异常
3. 否则，则按照继承关系，从下往上依次对C的各个父类进行第2步的搜索和验证过程
4. 如果始终没有找到合适的方法，则抛出java.lang.AbstractMethodError异常

其中，IllegalAccessError异常指的是程序试图访问或者修改一个属性或者调用一个方法，这个属性或者方法，你没有权限访问。一般的，这个会引起编译器异常。这个错误如果发生在运行时，就说明一个类发生了不兼容的改变。

5.8方法返回地址

方法的返回地址:用来存放调用该方法的pc计数器的值

一个方法的结束,有两种方式:

1. 正常执行返回：执行引擎遇到任意一个方法返回的字节码指令(return)，会有返回值传递给上层的方法调用者，简称正常完成出口

2. 出现异常信息，非正常返回：如果这个异常没有在该方法中进行处理，也就是本方法的异常表没有检测到任何匹配的异常处理器，就会导致方法退出,简称为异常完成出口

   但是，不论是哪种方式退出，在方法退出后都返回到该方法调用的位置。方法正常退出时，调用者的pc计数器的值作为返回地址，即调用该方法的指令的下一条指令的地址。而通过异常退出的，返回地址是要通过异常表来确定的，栈帧一般不会保存这部分信息的。
   注意：正常完成出口和异常完成出口的区别在于，通过异常完成出口退出的不会给他的上层调用者产生任何的返回值

5.9一些附加信息

附加信息

例如:对程序调试提供支持的信息

第六章 本地方法接口

6.1 什么是本地方法?

本地方法(Native Method)，就是一个java代码调用非java代码的接口：该方法的实现是由非java语言实现的，比如C/C++;

在定义一个native method时，并不提供实现体，因为其实现体是由非java语言在外面实现的；

本地接口的作用：是融合不同的编程语言为Java所用。它的初衷是融合C/C++程序；

注意：

• 标有native标识符可以和所有的其他标识符连用,但是abstract除外;

6.2 为什么要使用本地方法?

Java使用虽然十分的简便，但是有些层次的任务用Java实现并不是很容易，或者效率不高,此时我们想到使用本地方法；例如：与Java环境外进行交互；与操作系统进行交互等等。

6.3 本地方法的现状

目前除了一些和硬件有关的应用，已经使用的很少了

第七章 本地方法栈

7.1 概念

Java虚拟机栈是用于管理Java方法的调用，而本地方法则是用来管理本地方法的调用

本地方法栈：也是线程所私有的

7.2 本地方法栈的特点

1.本地方法是使用C语言编写的；

2.允许被实现成固定或者可动态扩展的内存大小:

• 如果线程请求分配的栈容量超过了本地方法栈允许的最大容量,Java虚拟机将会抛出StackOverflawError异常;

• 如果本地方法栈可以动态扩展,并且在尝试扩展时,无法申请到足够的内存,或者在创建新的线程时没有足够的内存区创建对应的本地方法栈,那么Java虚拟机将会抛出OutOfMemoryError异常;

3.本地方法栈的具体实现:Native Method Stack登记native 方法,在Execution Engine执行时加载本地方法库;

4.当某一个线程调用本地方法时,它就进入了一个全新的并且不受虚拟机控制限制的世界.它和虚拟机拥有同样的权限.

• 本地方法可以通过本地方法接口来访问虚拟机内部的运行时数据区

• 它甚至可以直接使用本地处理器中的寄存器;

• 直接从本地内存中的堆中分配任意数量的内存

5.并不是所有的JVM都支持本地方法.因为Java虚拟机规范并没有明确要求本地方法栈的使用语言,具体实现方法.数据结构等等.

注意：在HotSpot JVM中，直接将本地方法栈和虚拟机栈合二为一

第八章 堆空间(Heap)

8.1 堆的相关核心概念

一个JVM实例只存在一个堆内存，堆也是Java内存管理的核心区域

Java堆区在JVM启动的时候即被创建，其空间大小也被确定下来。是JVM管理的最大一块内存空间

堆的大小是可以进行调节的：Java虚拟机规范规定，堆可以处于物理不连续的内存空间，但是逻辑上它应该视为连续的。

所有的线程共享Java堆，在这里还可以划分出线程私有的缓冲区(Thread Local Allocation Buffer，TLAB)

"几乎"所有实例对象都会在堆上分配内存；

数组和对象可能永远不会存储在栈上，仅仅是在垃圾收集的时候才会被移除;

堆是GC执行垃圾回收的重点区域;

Java栈，堆，方法区在对象实例存储的示意图如下所示:

现代垃圾收集器大部分基于分代收集理论设计，堆空间在不同的JDK版本的细分如下图所示：

则在JDK7的整体运行时数据区(包括详细堆空间分布)如下图所示：

8.2 设置堆内存大小和OOM

指令	内容
-Xms	表示设置堆区的起始内存
-Xmx	表示设置堆区的最大内存

一旦堆中的内存超过了"-Xmx"所指定的最大内存时,将会抛出OutOfMemoryError异常;

通常会将-Xms和-Xmx两个参数配置相同的值,其目的在于:为了能够在java垃圾回收机制清理完堆区后不需要重新分隔计算堆区的大小,从而提高性能

默认情况下:

• 初始内存大小:物理电脑内存大小 / 64
• 最大内存大小:物理电脑内存 / 4

8.3 年轻代和老年代

存储在JVM中的java对象可以分为两类：

• 一类是生命周期较短的瞬时对象,这类对象的创建和消亡都非常迅速
• 另一类对象的生命周期非常长,在某些极端的情况下还能够与JVM的生命周期保持一致

Java堆区进一步细分,可以分为年轻代(YoungGen)和老年代(OldGen),其中年轻代又可以划分为Eden空间,Survivor0空间和Survivor1空间(有时也被称作from区和to区),如下图所示:

配置新生代与老年代在堆结构中的占比:

• 默认情况下:-XX:NewRatio = 2,表示新生代占1,老年代占2,新生代占整个堆的1/3;

• 可以修改:利用-XX:NewRatio = n:表示新生代占1,老年代占n,新生代占老年代的1/n

• 在HotSpot中,Eden空间和另外两个Survivor空间缺省所占的比例为8：1：1

• 可以利用-XX:SurvivorRatio = n来调整这个空间比例

几乎所有的Java对象都是在Eden区被new出来的

绝大部分的Java对象的销毁是在新生代中进行的,数据表明,新生代中80%的对象都是"朝生夕死"的

可以使用"-Xmn"来设置新生代最大内存大小

8.4 图解对象的分配过程

对象分配过程步骤:

步骤
1.new的对象先放伊甸园区,此区有大小限制;
2.当伊甸园区的空间被填满以后,程序又需要创建对象,JVM的垃圾回收器将对伊甸园区进行垃圾回收(GC),将伊甸园区的不再被其他对象所引用的对象进行销毁.再加载新的对象到伊甸园区
3.然后将伊甸园中剩下的存活的对象移动到0区
4.如果再次触发垃圾回收,此时上次幸存下来的放到幸存者0区的如果还没有被回收,此时全部移动到幸存者1区
5.如果再次经历垃圾回收,此时重新放回幸存者0区,接着再去幸存者1区,如此反复
6.当幸存者区中的对象的年龄到达阈值(默认15),会在垃圾回收时进入老年代区
7.在老年代区中,当老年代区被填满时,会触发GC:MajorGC,进行老年代的垃圾回收
8.若老年代区执行;垃圾回收还是发现无法进行对象的保存,就会产生OOM异常

总结:

1.针对幸存者0区,1区来说:复制之后有交换,谁空谁是to

2.关于垃圾回收:频繁在年轻代收集,很少在老年代收集,机会不再永久代/元空间收集

8.5 Minor GC,Major GC与Full GC

JVM在进行GC的时候,并非每次都是对上面三个内存(新生代,老年代,方法区)一起进行回收的,大部分时候回收都是指的新生代(年轻代)

针对HotSpot VM的实现,它里面的GC按照回收区域又分为了两个大类型:一个是部分收集(Partial GC).一个是整堆收集(Full GC)

部分收集:不是完整收集整个Java堆的垃圾收集,其中又分为

• 年轻代收集(Minor GC/Young GC)：只是对年轻代进行垃圾收集

• 老年代收集(Major GC/Old GC)：只是对老年代进行垃圾收集

• 混合收集(Mixed GC)：收集真个新生代以及部分老年代的垃圾收集；PS：目前只有G1 GC会有此种功法!

• 整堆收集(Full GC)：收集整个Java堆和方法区的垃圾收集

年轻代GC触发机制

1.当年轻代空间不足时,就会触发Minor GC,这里的年轻代指的是Eden区满,Survivor区满不会触发GC

2.因为Java对象大多都是朝生夕死的特性,所以Minor GC会比较地频繁,一般回收速度比较快.

3.Minor GC会触发STW(Stop The World,即让整个用户线程停止运行的状态),暂停其他用户的线程,等到垃圾回收结束,用户线程才会恢复运行.

老年代GC触发机制

1.指的是在老年代的GC,对象从老年代中消失

2.出现Major GC,经常会伴随至少一次的Minor GC(但也不是绝对的)

也就是说,在老年代空间不足的时候,会首先考虑触发Minor GC,如果之后空间还是不足,再触发Major GC

3.Major GC的速度一般比Minor GC慢十倍以上,STW的时间也会更长

4.如果Minor GC之后,内存空间还是不足,则报OOM

Full GC触发机制

1.调用System.gc()时,系统建议执行Full GC,但是不必然执行

2.老年代空间不足

3.方法区空间不足

4.通过Minor GC后进入老年代的平均大小大于老年代的可用内存

5.由Eden区,Survivor0区向Survivor1区复制时,对象大小大于To Space可用大小,则将该对象转存老年代,且老年代的可用内存小于该对象大小

PS:Full GC是开发中尽量避免的,这样暂停的时间会短很多

8.6 堆空间的分代思想

面试题: 为什么需要将Java堆进行分代处理?不分代就无法正常工作了?

经研究表明:不同对象的生命周期是不同的,其中70%~99%的对象时临时对象;

其中对堆进行划分:

• 年轻代：由Eden区,两块大小相同的Survivor区(to总为空)构成

• 老年代：存放年轻代中经历多次GC仍然存活的对象

其实，不分代程序能够正常运行的，分代的原因就是为了优化GC的性能，从而提高程序的运行性能.如果不进行分代操作，那么进行GC是会对堆区的所有区域进扫描，而很多对象其实都是“朝生夕死”的，当每次GC都对所有堆区的对象进行扫描回收，将提高GC的时间和降低其效率。但是我们如果分为新生代和老年代，其中新生代存放生命周期较短的对象，即“朝生夕死”或者刚新创建的一些对象，老年代存放生命周期比较长的对象，这样一来进行GC的时候，会先把生命周期较短的临时变量进行回收，不用扫描整个堆区，而是有针对性的进行扫描回收，这样可以节省很多时间和提高回收的效率，大大地提高了jvm的性能。

8.7 内存分配策略

如果对象在Eden区出生到经历第一次MInor GC后仍然存活,并且能被Survivor所容纳的话,将会被移动到Survivor空间中,并且设置age = 1,对象在Survivor区每熬过一次Minor GC,age就会自动加1,当它增加到一定的程度(default = 15)时,就会晋升老年代中;

老年代的年龄阈值设置:-XX:MaxTenuringThreshold来设置

分配策略:

1.优先分配到Eden

2.大对象直接分配到老年代中:尽量避免程序中出现过多的大对象(还"朝生夕死")

3.长期存活的对象分配到老年代

4.动态对象年龄判断

如果Survivor区中相同年龄的对象 > Survivor空间的一半,年龄大于或者等于该对象可以直接进入老年代,无需等到达到阈值以后

8.8 为对象分配内存:TLAB

为什么会存在TLAB(Thread Local Allocation Buffer)?

1.堆区是所有线程的共享区域,任何线程都可以访问到堆区中的共享数据

2.由于对象实例的创建在JVM中非常地频繁,因此在并发环境下从堆区中划分出内存空间是线程不安全的

3.为了避免多个线程操作同一地址,需要使用加锁等机制,进而影响了分配的速度

从而引出了TLAB:线程私有的缓冲区

什么是TLAB?

1.从内存模型而不是垃圾收集器的角度来说,对Eden区继续进行划分,JVM为每个线分配了一个私有缓存区域,它包含在Eden空间内

2.多线程同时分配内存时,使用TLAB可以避免一系列的非线程安全问题,同时还能够提升内存的分配的吞吐量,因此我们可以将这种内存分配方式叫做快速分配策略

基于TLAB的对象分配过程图如下所示:

8.8 堆空间的参数设置

参数说明网址

https://docs.oracle.com/en/java/javase/11/tools/tools-and-command-reference.html

测试堆空间常用的jvm参数：
  -XX:+PrintFlagsInitial : 查看所有的参数的默认初始值
  -XX:+PrintFlagsFinal  ：查看所有的参数的最终值（可能会存在修改，不再是初始值）
      具体查看某个参数的指令：   jps：查看当前运行中的进程
                             jinfo -flag SurvivorRatio 进程id
                             javap -v -p Xxx.class    
  -Xms：初始堆空间内存 （默认为物理内存的1/64）
  -Xmx：最大堆空间内存（默认为物理内存的1/4）
  -Xmn：设置新生代的大小。(初始值及最大值)
  -XX: NewRatio：配置新生代与老年代在堆结构的占比
  -XX: SurvivorRatio：设置新生代中Eden和S0/S1空间的比例
  -XX: MaxTenuringThreshold：设置新生代垃圾的最大年龄
  -XX: +PrintGCDetails：输出详细的GC处理日志
  打印gc简要信息：① -XX:+PrintGC   ② -verbose:gc
  -XX: HandlePromotionFailure：是否设置空间分配担保

空间分配担保:

8.9 堆是分配对象存储的唯一选择吗?

在《深入理解Java虚拟机》中，关于Java堆内存有这样的描述：

随着JIT编译期的发展与逃逸分析技术的逐渐成熟，栈上分配，标量替换优化技术将会导致一些微妙的变化，所有的对象都分配到堆上也会渐渐变得不是那么地绝对了…

在Java虚拟机中，对象是在Java堆上分配内存的，这是一个普遍的常识，但是，有一种特殊的情况，那就是**如果经过逃逸分析后发现，一个对象并没有逃逸出方法的话，那么就可能被优化到栈上分配。**这样就无需在堆上分配内存，也就无需进行垃圾回收了，这就是最常见的堆外存储技术。

逃逸分析概论:

• 如何将堆上的对象分配到栈，需要使用逃逸分析手段
• 这是一种可以有效地减少Java程序中同步负载和内存堆分配压力的跨函数全局数据流分析算法
• 通过逃逸分析，Java HotSpot编译器能够分析出一个新的对象的引用的使用范围从而决定是否将这个对象分配到堆上
• 逃逸分析的基本行为就是分析对象动态作用域：
  • 当一个对象在方法中被定义后，对象只能在方法内部使用，则认为没有发生逃逸
  • 当一个对象在方法定义后，它被外部方法所引用，则认为其发生逃逸。例如作为调用参数传递到其他地方中

注意：

1.判断是否逃逸分析:new的对象是否有可能在方法外被调用

2.开发中能够使用局部变量就不要轻易使用在方法外进行定义

逃逸分析之代码优化

使用逃逸分析，编译器可以对代码进行如下优化：

1. 栈上分配，即将堆分配转换为栈分配，如果一个对象在子程序中被分配，要使得指向该对象的指针永远不会逃逸，对象可能是栈分配的候选，而不是堆分配。
2. 同步忽略，如果一个对象被发现只能从一个线程被访问到，那么对于这个对象的操作就可以不考虑同步
3. 分离对象或者标量替换，有的对象可能不需要作为一个连续的内存结构存在也可以被访问到，那么对象的部分（或者全部）可以不存储在内存 ，而是存储在CPU寄存器中

其中:

1.栈上分配的场景:分别给成员变量赋值,方法返回值.,实例引用传递等等

2.同步消除----锁消除(如果一个对象被发现只能从一个线程中被访问到,那么对于这个对象来说,可以不考虑同步)

代码演示

public void test(){
        Object user = new Object();
        synchronized (user){
            System.out.println(user);
        }
}
//以上代码进行同步消除等价于以下代码:
public void test(){
        Object user = new Object();
        System.out.println(user);
}
    

3.分离对象或标量替换(HotSpot使用)
代码演示

public Class Point {
	int x;
	int y;
}
public void test(){
        Point point = new Point(1,2);
        System.out.println(point.getX() + point.getY());
}
//等价于
public void test(){
        //Point point = new Point(1,2);
        //System.out.println(point.getX() + point.getY());
        int x = 1;
        int y = 2;
        System.out.println(x + y);
}
    

8.10 本章小结

• 年轻代是对象的诞生，成长，消亡的区域，一个对象在这里产生，应用，最后被垃圾回收器回收，结束生命
• 老年代存放生命周期的对象，通常都是从Survivor区域筛选过来的Java对象。当然，也有特殊情况，我们知道普通的对象会被分配到TLAB上，如果对象过大，JVM会试图将其直接分配到Eden的其他位置上，如果对象太大，完全无法在新生代找到足够大的连续空闲空间，此时，JVM就会选择直接分配到老年代上。
• 当GC只发生在年轻代，回收年轻代对象的行为被称为MinorGC。当GC发生在老年代时则被称为MajorGC或者FullGC。一般的，MinorGC的发生概率要比MajorGC高很多，即老年代中垃圾回收发生的频率大大低于年轻代。

第九章 方法区

9.1 栈,堆,方法区的交互关系

首先我们再来回顾一下运行时数据区的结构图

从线程共享与否的角度来看:

栈,堆,方法区的交互关系如下所示:

9.2 方法区的理解

Java虚拟机规范中:尽管所有的方法区在逻辑上是属于堆的一部分,但是一些简单的实现可能不会选择去进行垃圾收集器或者进行压缩,但是对于HotSpot而言,方法区还有一个别名(Non-Heap堆),目的就是要和堆分离开;

所以:方法区可以看做是一块独立于Java堆的内存空间

1.方法区(Method Area)与Java堆一样,是各个线程共享的内存区域;

2.方法区在JVM启动的时候即被创建,并且它的实际物理内存空间中和Java堆区一样都可以是不连续的;

3.方法区的大小,跟堆空间一样,可以选择固定大小或者可扩展

4.方法区的大小决定了系统可以保存多少个类,如果系统定义了太多的类,导致了方法区溢出,虚拟机会抛出内存溢出错误:java.lang.OutOfMemoryError:PermGen space或者java.lang.OutOfMemoryError:Metaspace

5.关闭JVM就会释放这个区域的内存

HotSpot中方法区的演进

在jdk7即之前,习惯性把方法区称为永久代,jdk7开始,使用元空间取代了永久代

从本质上来说,方法区和永久代来说并不是等价的关系;因为只有HotSpot有永久代的概念,像BEA

JRokit/IBM J9不存在永久代的概念

JDK8由于Oracle收购了JRockit以后，将HotSpot和JRockit进行了整合，移除了永久代（Permant Generation），引进了元空间（MetaSpace），以下是jdk7和jdk8的jvm内存结构图：

元空间的本质和永久代是类似的:都是对JVM规范中方法区的实现.不过元空间与永久代最大的区别

在于:元空间不在虚拟机设置的内存中,而是使用的本地内存.

根据java虚拟机规范规定:如果方法区无法满足新的内存的分配需求,将会抛出OOM异常!

9.3设置方法区大小与OOM

jdk版本	设置
jdk7及以前	通过-XX:PermSize来设置永久代初始分配空间.默认值是20.75M ;-XX:MaxPermSize来设定永久代最大可分配空间 ;当JVM加载的类信息容量超过了这个值,会报异常:OutOfMemoryError:PerGenspace
jdk8及以后	元数据区大小和最大可分配空间可以使用参数-XX:Metaspace和-XX:MaxMetespaceSize来指定,默认windows下-XX:Metaspace为21M,-XX:MaxMetespaceSize为-1,表示没有任何限制;与永久代不同的是如果不指定大小,默认情况下,虚拟机会耗尽所有的可用系统内存,如果元数据区发生溢出,则会一样抛出异常:OutOfMemory:Metaspace

9.4 如何解决OOM异常?

• 要解决OOM异常或者heap space异常，一般的手段是首先通过内存映像分析工具对dump出来的堆转储快照进行分析，重点是确认内存中的对象是否是必要的，也就是要先分清楚到底是出现了内存泄露（Memory）还是内存溢出（Memory Overflow）、
• 如果是内存泄漏，则进一步通过工具查看泄漏对象到GC Roots的引用链，于是就能找到泄露对象是通过怎样的路径与GC Roots相关联并导致垃圾收集器无法自动回收他们的。
• 如果不存在内存泄漏，换句话说就是内存中的对象确实还必须存活着，那么就应当检查虚拟机的堆参数（-Xmx与-Xms），与机器物理内存对比看看是否还可以调大一些，从代码上检查是否存在某些对象生命周期过长，持有状态时间过长的情况，尝试减少程序运行期的内存消耗。

9.5 方法区的内部结构

java源代码加载JVM的过程:重点观察方法区

那么方法区中

到底存储了什么东西呢?

其中我们来具体分析一下上面方法区中包含的信息:

类型信息

对每个加载的类型(类Class,接口Interface,枚举enum,注解annotation),JVM必须在方法区中存储以下类型信息:

1.这个类型的完整有效名称(全名=包名.类名)

2.这个类型直接父类的完整有效名(对于interface或者java.lang.Object来说,没有父类)

3.这个类型的修饰符(public,abstract,final的某个子集)

4.这个类型直接接口的一个有序列表

域信息

JVM必须在方法区中保存类型的所有域的相关信息以及域的声明顺序

域的相关信息包括:

域名称,域类型,域修饰符(public,private,protected,static,final,volatile,tansient的某个子集)

方法信息:

JVM必须保存所有方法的以下信息,同域信息一样包括声明的顺序:

1.方法的名称

2.方法的返回类型(或者void)

3.方法参数的数量和类型(按照顺序)

4.方法的修饰符(public,private,protected,static,final,synchronized,native,abstract的一个子集)

5.方法的字节码(bytecodes,操作数栈,局部变量表即大小(abstract和native方法除外))

6.异常表(abstract和native方法除外)

每个异常处理的开始位置,结束位置,代码处理在程序计数器中的偏移地址,被捕获的异常类的常量池索引

PS:补充两个概念:non-final的类变量和final的类变量

non-final的类变量:

1.静态变量和类变量关联在一起,随着类的加载而加载,他们成为了类数据在逻辑上的一部分

2.类变量(即静态变量)被类的所有实例共享,即使没有类实例时你也可以访问它

final的类变量

被声明为final的类变量的处理方法则不同,每个全局变量在编译的时候就已经分配好了

运行时常量池VS常量池

在方法区中,内部包括运行时常量池,而字节码文件中包括常量池

对于一个有效的字节码文件来说,里面除了包含类的版本信息,字段,方法以及接口等描述信息以外,还包含一项信息,那就是常量池(Constant Pool Table),包括各种字面量和对类型.域和方法的符号引用,如下图所示:

那为什么字节码文件中需要常量池?

一个java源文件中的类,接口,编译后产生一个字节码文件.而Java中的字节码需要数据支持,通常这种数据会很大以至于不能直接存到字节码文件中去,换成另一种方式,可以存到常量池中去,这个字节码包含了指向常量池的引用.在前面栈帧的一个组成部分—动态链接—就会使用到这个常量池;

那么常量池里面又有什么东西呢?

1.数量值

2.字符串值

3.类引用

4.字段引用

5.方法引用

总结一下:
常量池可以看做是一张表,虚拟机指令根据这张常量表找到了要执行的类名,方法名,参数类型,字面量等类型;

接下来,我们再来讲解以下运行时常量池:

1.**运行时常量池(Runtime Constant Pool)**是方法区的一部分;

2.常量池是Class文件的一部分,用来存放编译期生成的各种字面量与符号引用,这部分内容将在类加载后存放到方法区的运行时常量池中;

3.运行时常量池,在加载类和接口到虚拟机后,就会创建对应的运行时常量池

4.JVM为每一个已加载的类型(类和接口)都维护这一个常量池.池中的数据项向数组项一样,是通过索引进行访问的;

5.运行时常量池中包含了多种不同的常量,包括编译期就已经确定下来的数值字面量,也包括到运行时期解析后才能够得到的方法或者字段引用等,此时不再是常量池中的符号引用了,这里换成了真实的地址。

运行时常量池相对于class文件常量池的另一个重要特征:具备动态性

String.intern()方法的使用**----后面会重点讲解

6.运行时常量池类似传统编程中的符号表(Symbol table),但是它所包含的数据比符号表要更加的丰富

7.当创建类或者接口的运行时常量池时,如果构造运行时常量池所需的内存空间超过了方法区提供的最大值,则会抛OutOfMemoryError异常.

9.6 方法区的演进细节

首先,需要明确:只有HotSpot才会有永久代!

HotSpot中方法区的变化:

下面是jdk不同版本对于方法区的不同演进过程图:

JDK6及之前的版本的方法区：

JDK7版本的方法区：

JDK8及以后的方法区：

面试题:永久代为什么要被元空间替换?

回答：由于永久代存在着很多的弊端：

1.为永久代设置空间大小是很困难的；某些场景下，如果动态加载的类过多，容易产生Perm区的OOM。而元空间和永久代最大的区别在于：元空间并不在虚拟机中，而是使用的本地的内存，因此，默认情况下，元空间的大小仅仅受到本地内存的限制。

2.对永久代进行性能的调优是很困难的；如果采用永久代，则内存不足并不可少会触发Full GC，但这样会造成应用程序线程的停顿时间过长，对于性能是有很大的弊端的，而且对于Full GC，我们并不能进行多大程度的性能调优，而采用元空间，直接使用的就是本地的内存，则很大程度上的避免Full GC的发生。

面试题: StringTable为什么要被调整?

jdk7中将StringTable放到了堆空间中。因为永久代的回收效率很低，在full gc的时候才会触发，而full gc是老年代的空间不足，永久代不足才会触发。这就导致了StringTable的回收效率不高。而我们的开发中会有大量的字符串被创建，回收效率低，导致永久代内存不足。此时我们更改将字符串放到堆中，能够及时回收内存。

静态变量放在哪里?

静态引用的对象实体始终都存在堆空间中 !

9.7 方法区的垃圾回收

常量池的垃圾回收:

类的垃圾回收:

9.8 总结

第十章 对象的实例化,内存布局和访问定位

10.1 对象的实例化

对象的实例化图:

10.2 对象创建的方式

序号	方式
方式1	new(或者调用某些类(XxxFactory,XxxBuilder等等)的静态方法)
方式2	Class的newInstance() jdk1.8及之前反射的方式:不过只能调用空参构造器,权限必须是public
方式3	Constructor的newInstance() jdk1.9以后的反射方式:可以调用空参,带参的构造器,权限没有要求
方式4	clone(),不调用任何构造器,当前类需要实现Cloneable接口,实现clone方法
方式5	使用反序列化,从文件中,从网络中获取一个对象的二进制流
方式6	第三方库Objensls

10.3 对象创建的步骤

步骤	内容
第一步	判断对象对应的类是否加载,连接,初始化?虚拟机遇到一条new指令,首先检查这个指令的参数能否在Metaspace的常量池中定位到一个类的符号引用,并且检查这个符号引用代表的类是否已经被加载,解析和初始化了(即判断类元信息是否存在?)如果没有,那么在双亲委派模式下,使用当前类加载器以ClassLoader+包名+类名为key的方式进行查找对应的class文件,如果没有找到,则会抛出ClassNotFoundException异常,如果找到,则进行类加载,并生成相对应的Class类对象
第二步	为对象分配内存:如果内存是规整的,则以指针碰撞的方式进行分配;如果内存不规整,虚拟机需要维护一个列表,利用空闲列表分配;选择哪种分配方式由Java堆是否规整决定,而Java堆是否规整又由所采用的垃圾回收器是否带有压缩整理功能决定
第三步	处理并发安全问题:采用CAS配上失败重试保证更新的原子性,每一个线程预先分配一块TLAB
第四步	初始化分配到的空间:所有属性设置默认值,保证对象实例字段在不进行赋值的情况下能够直接使用
第五步	设置对象的对象头
第六步	执行init()方法进行初始化

10.4 对象的内存布局

10.5 对象的访问定位

JVM是如何通过栈帧上的对象引用访问到其内部的对象实例的? — 通过栈上的reference访问

对象访问的方式主要有两种:

1.直接指针(HotSpot采用此种方式)

2.句柄访问

第十一章 直接内存(Direct Memory)

直接内存概述

1.不是虚拟机运行时数据区的一部分,也不是Java虚拟机规范中定义的内存区域

2.直接内存时Java堆外的,直接向系统申请的内存区间

3.来源于NIO,通过存在堆中的DirectByteBuffer操作Native内存

4.通常,访问直接内存的速度会优于Java堆,即读写性能高

因此，处于性能的考虑，读写频繁地场合可能会考虑使用直接内存。Java的NIO库允许Java程序使用直接内存，用于数据缓冲区

对比直接缓冲区和非直接缓冲区读写文件的过程：

注意:

1.直接内存也可能导致OutOfMemoryError异常;

2.由于直接内存在Java堆外,因此它的大小直接受到-Xmx指定的最大堆大小,但是系统内存是有限的,Java堆和直接内存的总和依然受限于操作系统能给出的最大内存.

3.直接内存的缺点

• 分配回收成本较高
• 不受JVM内存回收管理

4.直接内存大小可以通过MaxDirectMemorySize设置

5.如果不指定,默认与堆的最大值-Xmx参数值一致

第十二章 执行引擎

12.1 执行引擎概述

1.执行引擎是Java虚拟机核心的组成部分之一

2.虚拟机是相对于"物理机"的概念,这两个机器都有代码执行,其区别是物理机的执行引擎是直接建立在处理器,缓存,指令集和操作系统层面上的,而虚拟机的执行引擎则是由软件实现的,因为可以不受物理条件制约地定制指令集与执行引擎的结构体系,能够执行那些不受硬件直接支持的指令集格式.

3.JVM的主要任务是负责装载字节码到内部,而执行引擎的任务则是将字节码解释/编译为对应平台的本地机器指令(即机器码).

执行引擎的工作过程:

第一步:执行引擎在执行的过程中究竟需要执行什么样的的字节码指令完全依赖于pc计数器;

第二步:每当执行完一项指令操作以后,pc寄存器就会更新下一条需要被执行的指令地址;

第三步:当然方法在执行过程中,执行引擎有可能会通过存储在局部变量表中的对象引用准确定位到存储在Java堆区中的对象实例信息,以及通过对象头中的元数据指针定位到目标对象的类型信息

12.2 Java代码编译和执行的过程

大部分的代码转换成物理机的目标代码或者虚拟机能执行的指令集之前,需要经历的流程如下图所示:

Java代码编译是由Java源码编译器来完成,流程图如下:

Java字节码的执行是由JVM执行引擎来完成,流程图如下所示:

那么,什么是解释器(Interpreter),什么是JIT编译器?

解释器:当Java虚拟机启动时会根据预定义的规划对字节码采用逐行解释的方式执行,将每条字节码文件中的内容"解释"为对应平台的本地机器指令来执行;

JIT(Just In Time Compiler)编译器:就是虚拟机将源代码直接编译成和本地机器平台相关的机器语言

面试题:为什么说Java是半编译半解释型语言?

因为现在的Java虚拟机在执行java代码的时候,通常都会将解释执行和编译执行二者结合起来进行,其中的编译器即为我们的JIT即是编译器.

12.3机器码,指令,汇编语言

机器码,指令,汇编语言几者之间的关系图:

字节码的理解：

• 字节码是一种中间状态（中间码）的二进制代码（文件），它比机器码更加抽象，需要直译器转译以后才能成为机器码
• 字节码主要是为了实现特定软件运行和软件环境，与硬件环境无关
• 字节码的实现方式是通过编译器与虚拟机器，编译器将源码编译成字节码，特定平台上的虚拟机将字节码转译为可以直接执行的指令

12.4 解释器

解释器：即将字节码中的内容"翻译"成对应平台的本地机器指令执行

发展历程：从字节码解释器------------->模板解释器

其中字节码解释器执行时通过纯软件代码模拟字节码的执行,效率比较低

而模板解释器则是将每一条字节码和一个模板函数相关联,模板函数中直接产生这个字节码的机器码,从而很大程度上提高了解释器的性能

在HotSpot VM中,解释器主要有Interpreter模块和Code模块构成

• Interpreter模块:实现了解释器的核心功能

• Code模块:用来管理HotSpot VM运行时生成的本地机器指令

12.5 JIT编译器

上面的解释器是通过拿到源代码编译成的字节码文件，将其逐行解释转换成机器码执行；

而这里的JIT即时编译器则是编译执行(直接编译成机器码)

HotSpot VM 采用则是解释器和即时编译器并存的架构;在Java虚拟机运行时,解释器和及时编译器能够相互协作,各自取长补短,尽力选择最合适的方式来权衡编译本地代码的时间和直接解释执行代码的时间.

总结:
1. 一般来说,JIT即时编译出来的机器码性能比解释器要高
2. C2编译器启动时长比C1编译器慢,但是,当系统稳定执行以后,C2编译器的执行速度远远快于C1编译器

面试题: 既然HotSpot VM已经内置了即时编译器JIT,为什么还需要再使用解释器"拖累"程序的执行性能呢?

首先我们需要明确的是，当程序启动的时候，解释器可以马上发挥作用，省去了编译的时间，可以立即执行。

编译器要想发挥作用，把代码编译成本地代码，需要一定的执行时间。但是编译为本地代码后，执行效率高。

所以：

尽管，JRockit VM中的程序的执行性能会非常高效，但是程序启动的时候必然需要花费更长的时间来进行编译。对于服务端应用来说，启动时间并非是关注的重点，但是对于那些看中启动时间的应用场景来说，或者就需要采用解释器和即时编译器并存的架构来换取一个平衡点。在这种模式下，当Java虚拟器启动时，解释器可以首先发挥作用，而不必等待即时编译器全部编译完成再执行，这样就可以省去需要不必要的编译时间，随着实践的推移，编译器发挥作用，把越来越多的代码编译成本地代码，获得更高的执行效率。

第十三章 垃圾回收概述

首先,抛出三个垃圾回收的经典面试题:

• 哪些内存需要回收?

• 什么时候回收?

• 如何回收?

13.1 什么是垃圾

垃圾是指在程序运行中没有任何指针指向的对象,这些对象就是需要被回收的垃圾,如果不及时对内存中的这些"垃圾"进行清理,那么垃圾对象所占的内存空间会一直保留到应用程序结束,被保留的空间将无法被其他对象使用,甚至可能导致内存溢出.

13.2 为什么要需要GC?

13.3 Java 的垃圾回收机制

java的垃圾回收机制：自动内存管理机制

优点:降低内存泄露和内存溢出的风险,让java开发人员更专注于业务的开发

缺点:弱化了java程序员在内存溢出定位和解决的能力

Java堆是垃圾收集器的工作重点:频繁收集年轻代,较少收集老年代,基本不动Perm区/元空间

第十四章 垃圾回收相关算法

14.1 垃圾标记阶段------引用计数算法&可达性分析算法

14.1.1 引言

在堆中存放着几乎所有的java对象实例,在GC执行垃圾回收之前,首先**需要区分内存中哪些对象是存活对象,哪些对象是已经死亡的对象.**只有被标记为已经死亡的对象,GC才会在执行垃圾回收时,释放掉所占用的内存空间.

那么在JVM中究竟如何标记一个死亡对象呢,简单来说**,当一个对象已经不再被任何存活着的对象继续引用时,我们可以宣判其已经死亡**.

判断对象存活一般有两种方式:
1.引用计数算法

​ 2.可达性分析算法

14.1.2 引用计数算法:Reference Counting

该算法实现较为简单:对每个对象保存一个整型的引用计数器属性,用来记录对象被引用的情况

对于一个对象A,只要任何对象引用了A,则A的引用计数器就会加1,当引用失效时,引用计数器就会减1.只要对象A的引用计数器的值为0,则表示对象A不可能再被使用,可进行回收.

该算法的优点:

• 实现简单,垃圾对象便于识别;判定效率高,回收没有延迟性

该算法的缺点:

• 它需要单独的字段存储计数器,这样的做法会增加存储空间的开销
• 每次赋值都需要更新计数器,伴随着加法和减法操作,这增加了时间开销
• 引用计数器有一个严重的问题,即无法处理循环引用的问题.这是一个致命的缺陷,导致Java的垃圾回收器没有使用该算法

上面提到循环引用的问题:这里举例说明：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dIGop9ut-1634028464286)(.\imgs\引用计数.jpg)]

上面若突然将P指向null,此时p原先指向的对象的引用计数器的值会变成1,没有减到0,此时由于p指向了null,导致原先p指向的对象无法被判定是死亡的,同样造成了内存泄露的问题.

总结:

• 引用计数算法,是很多语言的资源回收选择,例如Phython
• Java并没有选择引用计数算法,是因为其存在一个基本的难题,也就是很难处理循环引用的问题
• Python是如何解决循环引用问题的?
  • 手动解除:很好理解,就是在合适的时机,解除引用关系
  • 使用弱引用Weakref,Weakref是Python提供的标准库,旨在解除循环引用

14.1.3 可达性分析算法 (或者称为根搜索算法,追踪性垃圾收集)

相对于引用计数算法而言,可达性分析算法不仅同样具备实现简单和执行高效等特点,更重要的是该算法解决了引用计数算法的循环引用的问题

Java选择了该算法作为垃圾标记的默认算法

首先我们需要引入一个概念------GC Roots(根集合就是一组必须活跃的引用)

基本思路：

1.可达性分析算法是以根对象集合(GC Roots)为起始点,按照从上至下的方式搜索被根对象集合所连接的目标对象是否可达

2.使用可达性分析算法后,内存中的存活对象都会被根对象集合直接或者间接连接着,搜索所走过的路径称为引用链(Reference Chain)

3.如果目标对象没有任何引用链相连,则认为是不可达的,就意味着该对象已经死亡,可以标记为垃圾对象

4.在可达性分析算法中,只有能够被根对象集合直接或者间接连接的对象才是存活对象
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3A5EkxFC-1634028464287)(.\imgs\可达性分析算法.jpg)]

在Java语言中,GC Roots包括以下元素：

• 虚拟机栈中引用的对象：比如各个线程被调用的方法中使用的参数，局部变量等等

• 本地方法栈内JNI（本地方法）引用的对象

• 方法区中类静态属性引用的对象

• 方法区中常量引用的对象，例如字符串常量池中的引用

• 所有被同步锁synchronized持有的对象

• Java虚拟机内部的引用

• 反映java虚拟机内部情况的JMXBean，JVM本地代码缓存等等

• 除了这些固定的GC Roots集合以外，根据用户所选用的垃圾回收器以及当前回收的内存区域不同，还可以有其他对象“临时性”地加入，共同构成完整的RC Roots集合。

• 小技巧：由于Root采用栈方式存放变量和指针，所以如果说一个指针，它保存了堆内存里面的的对象，但是自己又不存放在堆内存里面，那么它就是一个Root

注意：
1.如果要使用可达性分析算法来判断内存是否可回收,那么分析工作必须在一个能保障一致性的快照中进行.
2.上面的要求也是导致GC进行时必须"Stop The World"的一个重要原因
PS:即使是号称几乎不会发生停顿的CMS收集器中,枚举根节点时也是必须要停顿的

14.2 对象的finalization机制

Java语言提供了对象终止(finalization)机制来允许开发人员提供对象被销毁之前的自定义处理逻辑

当垃圾收集器发现没有一个引用指向一个对象,即:垃圾回收此对象之前,总会先调用这个对象的finalize()方法;

finalize()方法允许在子类中被重写,用于在对象被回收时进行资源释放,通常这个方法中进行一些资源释放和清理的工作,比如关闭文件,套接字和数据库连接等等;

永远不要主动调用某个对象的finalize()方法,应该交给垃圾回收机制调用!理由如下所示:

1.在finalize()时可能会导致对象复活

2.finalize()方法的执行时间是没有保障的,它完全由GC线程决定,极端情况下,若不发生,则finalize()方法将没有执行机会;

3.一个糟糕的finalize()会严重影响GC的性能

由于finalize()方法的存在,导致虚拟机的对象一般处于三种可能的状态：

• 可触及的：从根节点开始，可以到达这个对象
• 可复活的：对象的所有引用都被释放，但是对象有可能在finalize（）中复活
• 不可触及的：对象的finalize（）被调用，并且没有复活，那么就会进入不可触及状态。不可触及的对象不可能被复活，因为finalize（）只能被调用一次
• 在以上三种状态中，因为由于finalize（）方法的存在，进行的区分，只有在对象不可触及时才可以被回收。

14.3 垃圾清除阶段算法------标记-清除算法

当成功地分出内存中存活对象和死亡对象以后,GC接下来的任务就是执行垃圾回收了,释放掉无用对象所占用的内存空间,以便有足够的可用内存空间为新对象分配内存.

目前在JVM中比较常见的三种垃圾算法是标记-清除算法(Mark-Sweep),复制算法(CopIng),标记-压缩算法(Mark-Compact)

标记-清除(Mark-Sweep)算法

执行过程:

• 当堆中的有效空间(available memory)被耗尽的时候，就会停止整个程序(STW)，然后进行两项工作，第一项是标记，第二项是清除。

• 标记：Collector从引用根节点开始遍历，标记所有被引用的对象。一般是在对象的Header中记录为可达对象。

• 清除：Collector对堆内存从头到尾进行线性的遍历，如果发现某个对象在Header中没有标记为可达对象，则将其回收。

标记-清除算法的缺点:

• 1.效率不算高
• 2.在进行GC的时候,需要停止整个应用程序,导致用户体验差
• 3.这种方式清理出来的空闲内存是不连续的,产生内存碎片.需要维护一个空闲列表
• 注意:何为清除?
  这里所谓的清除并不是真正的置空,而是把需要清除的对象地址保存在空闲的地址列表里.下次有新对象需要加载时,判断垃圾的位置空间是否够,如果够,就存放.

14.4 垃圾清除算法-----复制算法

为了解决标记-清除算法在垃圾收集效率方面的缺陷,复制算法(Copying)应运而生;

复制算法思想:

将活着的内存空间分为两块,每次只使用其中的一块,在垃圾收集时将正在使用的内存中的存活对象复制到未被使用的内存块中,之后清除正在使用的内存块中的所有对象,交换两个内存的角色,最后完成垃圾的回收;

复制算法的特点

优点:

• 1.没有标记和清除过程,实现简单,运行高效
• 2.复制过去以后保证空间的连续性,不会出现"碎片"问题

缺点 :

• 1.此算法需要两倍的内存空间
• 2.对于G1这种拆分成大量region的GC来说,复制而不是移动,意味着GC需要维护region之间对象的引用关系,不管是内存占用还是时间开销也不小

注意：

• 如果系统的垃圾对象很多,复制算法需要复制的存活对象数量并不会太大,或者说非常低才行(例如:新生代的垃圾回收,新生代中的Survivor0和Survivor1区的垃圾回收思想)

14.5 垃圾清除算法-----标记-压缩(整理)算法

背景：

• 复制算法虽然高效,但是必须建立在存活对象少,垃圾对象多的前提之下,这种情况在新生代比较适合.但是对于老年代来说,大部分对象都是存活的对象,则不再适用于复制算法;
• 而标记-清除算法虽然可以应用于老年代的垃圾收集,但是这种算法执行效率过低,并且执行完垃圾收集以后会产生内存碎片,故垃圾-压缩(Mark-Compact)算法由此诞生.

标记-压缩算法执行过程:

• 第一阶段:和标记-清除算法发一样,Collector从引用根节点开始遍历,标记所有被引用的对象.一般是在对象的Header中记录为可达对象.
• 第二阶段:将所有存活的对象压缩到内存的一端,按照顺序进行排放
• 之后,清理边界外所有的空间

标记-压缩算法的最终效果等同于标记-清除算法执行完成以后,再进行一次内存碎片的整理工作,因此,也可以把它称为标记-清除-压缩算法(Mark-Sweep-Compact)

对于标记-清除算法来说:标记清除算法是一种非移动式的回收算法,标记压缩 是移动式的.是否移动回收后的存活对象是一项优缺点并存的风险决策.

可以看到:标记的存活对象将会被整理,按照内存地址一次进行排列,而未被标记的内存会被清理掉,如此一来,当我们需要给新对象分配内存时,JVM只需要持有一个内存的起始地址即可,这比维护一个空闲列表显然要方便很多.

引入知识点:指针碰撞(Bump the Pointer)

如果内存空间以规整和有序的方式进行分布,即已用和未用的内存都各在一边,彼此之间维系着一个记录下一次分配起始点的标记指针,当为新对象分配内存时,只需要通过修改指针的偏移量将新对象分配在第一个空闲内存位置上,这种分配方式叫做指针碰撞(Bump the Pointer)

标记-压缩算法的特点

优点:

• 1.消除了标记-清除算法当中,内存区域分撒的缺点,我们需要给新对象分配内存时,只需要持有一个内存的起始地址即可;
• 2.消除了复制算法当中,内存减半的高额代价

缺点:

• 1.从效率上来说,标记-整理算法要低于复制算法
• 2.移动对象时,如果该对象被其他对象引用,则还需要调整引用的地址
• 3.移动过程中,需要全称暂停用户的应用程序,即STW

总结:

对比上面的三种清除的算法:

14.6 其他算法了解

分区算法

一般来说,在相同的条件下,堆空间越大,一次GC时所需要的时间就越长,有关GC产生的停顿也越长,为了更好地控制GC产生的停顿时间,将一块大的内存区域分割成多个小块,根据目标的停顿时间,每次合理的回收若干个小区间,而不是整个堆空间,从而减少一次GC所产生的停顿.

分区算法:将按照对象的生命周期长短划分为两个部分,分区算法将真个堆空间分为连续的不同的小区间.每个小区间都独立使用,这种算法的好处是可以控制一次回收多少个小区间:其中,G1 GC就采用这种分区算法思想.

第十五章 垃圾回收相关概念

15.1 System.gc()的理解

如下代码所示:我们进行System.gc()时，按照前面是说的,一般如果进行垃圾回收之前，会先调用finalize()方法，这里我们重写finalize()方法，里面打印一段语句，当执行以后：会发现并不是每次都会打印我们重写的语句，说明System.gc()时并不能确定马上执行GC处理。

15.2 内存溢出(OOM)

内存溢出:OutofMemoryError

一般上面所说的没有空闲内存指的就是**没有空闲的堆内存,**而导致Java虚拟机堆内存不足的原因主要有两点:

这里面隐含的一层意思,在抛出OutOfMemoryError之前,通常垃圾收集器会被触发,尽其所能去清理出空间.

例如: 在引用机制分析中,涉及到JVM会去尝试回收软引用指向的对象等
在java.nio.BIts.reserveMemeory()方法中,我们可以清楚的看到System.sc()会被调用,以清理空间.

当然,也不是在任何情况下垃圾收集器都会被触发的
比如:我们去分配一个超大对象,类似一个超大数组超过堆的最大值,JVM可以判断出垃圾收集并不能解决这个问题,所以直接抛出OutOfMemoryError异常.

15.3 内存泄露(Memory Leak)

15.3 STW(Stop The World)

15.4 垃圾回收的并行和并发

并发(Concurrent):

并行(Parallel):

并发VS并行:

而对于垃圾回收来说:

并行(Parallel):指的是多条垃圾收集线程并行工作,但此时用户线程仍然处于等待状态.

比如:ParNew,Parallel Scavenge,Parallel Old

串行(Serial):单线程执行:如果内存不够,暂停程序,启动垃圾收集器进行垃圾回收.等垃圾收集完毕,再启动程序的线程.

并发(Concurrent):指的是用户线程与垃圾收集器线程同时执行(但不一定是并行的,可能交替执行)垃圾收集线程在执行时不会停顿用户程序的运行.

15.5 安全点和安全区域

安全点(SafePoint):

程序执行时并非在所有的地方都能停顿下来进行GC,只有在特点的位置才能停顿下来进行GC,这些位置被称为"安全点";

Safe Point的选择很重要,如果太少可能会导致GC等待的时间太长,如果太频繁可能会导致运行时的性能问题.大部分的指令的执行时间都是非常地短暂的,通常会根据"是否让程序长时间执行的特征"为标准.比如:选择一次执行时间较长的指令作为Safe Point,例如方法的调用,循环跳转,异常跳转等等.

那么如何在GC发生时,检查所有的线程都跑到了最近安全点停顿下来了呢?

• 方式1：抢先式中断(目前不使用了)
  首先中断所有线程,如果还有线程不在安全点,让线程跑到安全点
• 方式2：主动式中断
  设置一个中断标志,各个线程运行到Safe Point的时候主要轮询这个标志,如果中断标志为真,则将自己进行中断挂起

安全区域(Safe Region):

安全区域指的是一段代码中,对象的引用关系不会发生变化,在这个区域中的任何位置开始GC都是安全的.

实际执行过程:

1.当线程运行到Safe Region的代码时,首先标识已经进入Safe Region,如果这段时间进行GC.JVM会忽略标识为Safe Region状态的线程

2.当线程即将离开Safe Region时,会检查JVM是否已经完成GC,如果完成了,则继续执行,否则线程必须等待直到收到可以安全离开Safe Region的信号为止.

15.6 引用

面试题: 强引用,软引用,弱引用,虚引用有什么区别?具体的使用场景是什么?

强引用(Strong Reference)------不回收

软引用(Soft Reference)------内存不足即回收

注意:可以通过java.lang.ref.SoftReference类来实现软引用

弱引用(Weak Reference)------发现及回收

注意:可以通过java.lang.ref.WeakReference类来实现弱引用

弱引用对象和软引用对象最大的不同在于,在GC进行回收之前,需要通过算法检查是否回收软引用对象;而对于弱引用对象,GC总是进行垃圾回收的.弱引用对象将更容易,更快地被GC回收.

虚引用(Phantom Reference)------对象回收跟踪

终结器引用(Final Reference)------了解即可

第十六章 垃圾回收器

16.1 垃圾回收器的分类与性能指标

16.1.1 GC的分类

1.按照线程数来进行划分,可以分为串行垃圾回收器和并行垃圾回收器

串行垃圾回收器	并行垃圾回收器
同一时间段只允许一个cpu用于执行垃圾回收操作,此时垃圾线程被暂停,直至垃圾收集工作结束	并行收集可以运用多个cpu同时执行垃圾回收,因此提升了应用的吞吐量,不过并行回收和串行回收一样,采用独占式,使用了STW机制

2.按照工作模式进行划分,可以分为并发式垃圾回收器和独占式垃圾回收器;

并发式垃圾回收器与应用程序交替工作,以尽可能减少应用程序的停顿时间;
独占式垃圾回收器(STW)一旦运行,就需要停止应用程序中的所有用户线程,直到垃圾回收过程完全结束为止;

3.按照碎片处理方式划分:可以分为压缩式垃圾回收器和非压缩式垃圾回收器

压缩式垃圾回收器会在回收完成以后,对存活对象进行压缩整理,消除回收后的碎片;
非压缩式的垃圾回收器不进行碎片的压缩整理工作

4.按照工作的内存区间划分:可以分为年轻代垃圾回收器和老年代垃圾回收器

16.1.2 评估GC的性能指标

性能指标	内容
吞吐量	指的是运行用户代码的时间占总运行时间的比例(总运行时间 = 程序的运行时间 + 内存回收的时间)
暂停时间	执行垃圾收集时,程序的工作线程被暂停的时间
垃圾收集开销	吞吐量的补数,垃圾收集所用时间占总运行时间的比例
收集频率	相对于应用程序的执行,收集操作发生的频率
内存的占用	Java堆区所占的内存大小
快速	一个对象从诞生到被回收所经历的时间

其中,吞吐量,暂停时间和内存占用称为评估GC性能的重要三点 !,后随着硬件的发展,内存占用慢慢得到了解决,其中由于硬件性能的提升有助于降低垃圾收集器运行时对应用程序的影响,即提高了吞吐量,而内存的扩大,对延迟反而带来了负面效果.

吞吐量(Throughput)

暂停时间(Pause Time)

吞吐量VS暂停时间

目前GC追求最大性能标准则是:在最大吞吐量优先的情况下,降低停顿时间.

16.2 不同的垃圾回收器概述

垃圾收集器的发展史:

其中:

上面的7款垃圾收集器与垃圾分代直接的关系图如下所示:

同时,垃圾收集器在年轻代和老年代的组合使用关系随着jdk版本的演进发生着一些变化:

1.两个收集器之间有连线,表明他们可以配合使用:

Serial GC/Serial Old GC

Serial GC/CMS

ParNew GC/Serial Old GC

ParNew GC/CMS

Parallel Scavenge GC/Serial Old GC

Parallel Scavenge GC/Parallel Old GC

G1 GC

2.其中,Serial Old GC 作为CMS 出现"Concurrent Mode Failure"失败的后备方案.

3.(红色虚线)由于维护和兼容性测试的成本,在JDK 8时将Serial Old + CMS,ParNew + Serial Old这两个组合声明为废弃,同时,在JDK9中完全取消了这两个组合的支持(即移除)

4.(绿色虚线)JDK14中,弃用了Parallel Scavenge和Serial Old的组合

5.(青色虚线)JDK14中,删除了CMS垃圾回收器

如何查看默认的垃圾收集器?

-XX:+PrintCommandLineFlags:查看命令行相关参数(包含使用的垃圾收集器)

使用命令行指令:jinfo -flag 相关垃圾回收器参数 进程ID

16.3 Serial回收器------串行回收

1.Serial收集器是最基本,历史最悠久的垃圾收集器了.JDK1.3之前回收新生代唯一的选择;

2.Serial GC作为HotSpot中Client模式下的默认新生代垃圾回收器

3.Serial GC 采用的是复制算法,串行回收和"Stop The World"机制的方式执行垃圾内存回收的

4.除了年轻代之外Serial 收集器还提供了用于执行老年代垃圾收集的Serial Old GC,Serial Old GC收集器同样也采用了串行回收和"Stop The World"机制,只不过内存回收算法使用的是标记-压缩算法.

注意:

1.Serial Old是运行在Client模式下的默认的老年代的垃圾收集器
2.Serial Old在Server模式下主要有两个用途:一是与新生代的ParallelScavenge配合使用,二是作为老年代CMS收集器的后备垃圾收集方案

通过上图该垃圾回收器的工作流程可以发现:

这个垃圾收集器是一个单线程收集器,但是它的"单线程"的意义并不仅仅说明他只会使用一个CPU或者一条收集线程去完成垃圾收集 工作,更重要的是在他进行垃圾收集的时候,必须暂停其他所有的工作线程,直到他收集结束(Stop The World).

Serial GC的特点：

16.4 ParNew回收器------并行回收

ParNew GC:即是Serial GC的多线程版本

ParNew收集器除了采用并行回收的方式进行内存垃圾回收以外,与Serial几乎没有其他区别:同样采用复制算法,"Stop The World"机制;

ParNew是很多JVM运行在Server模式下年轻代的默认垃圾收集器

ParNew GC的工作流程如下所示:
对于新生代来说,回收次数频繁,则使用并行方式高效
对于老年代,回收次数少,则使用串行方式节省资源

16.5 Parallel回收器------吞吐量优先

HotSpot的年轻代中除了拥有ParNew收集器是基于并行回收的以外,Parallel Scavenge收集器同样采用了复制算法,并行回收,“Stop The World"机制”;

那么是否Parallel收集器的出现是多此一举呢?
1.和ParNew收集器不同,Parallel Scavenge收集器的目标则是达到一个可控制的吞吐量,它也被称作吞吐量优先的垃圾收集器;
2.自适应调节策略也是一个重要的区别;

高吞吐量则是可以高效地利用cpu时间,尽快的完成程序的运算任务,主要适合后台运算而不需要太多交互的任务.因此,常见在服务器环境中使用.例如,那么执行批量处理,订单处理,工资支付,科学计算的应用程序;

Parallel 收集器在JDK1.6时提供了执行老年代收集的Parallel Old 收集器,用来替代老年代的Serial Old 收集器

Parallel Old收集器采用了标记-压缩算法,但同样也是基于并行回收和"Stop The World"机制;

Paralel Scavenge GC/Parallel Old GC工作流程入下图所示:

注意:

1.在程序吞吐量优先的应用场景中,Parallel收集器和Parallel Old收集器的组合,在Server模式下的内存回收性能很不错;
2.在Java8(目前开发热流版本)中,默认的垃圾收集器即是Parallel GC;

Parallel GC的相关参数配置：

16.6 CMS回收器------低延迟

在JDK1.5时期,HotSpot推出了一款在强交互应用中几乎可以认为有划时代意义的垃圾回收器,即我们的CMS(Concurrent-Mark-Sweep)垃圾回收器,这款垃圾回收器是HotSpot虚拟机中第一款真正意义上的并发垃圾回收器,它第一次实现了让垃圾收集和用户线程同时工作.

CMS收集器的关注点是尽可能地缩短垃圾收集时用户线程的停顿时间.停顿时间越短(低延迟)就越适合和用户进行交互的程序,良好的响应速度能提升用户的体验.

• 目前很大一部分的java引用都集中在互联网或者B/S系统的服务端上,这类应用尤其重视服务的响应速度,希望系统停顿时间最短,以给用户带来较好的体验.
• CMS垃圾回收器采用标记-清除算法,并且也会出现"Stop-The-World"

但是,不幸的是,CMS作为老年代的收集器,却无法与新生代收集器Parallel Scavenge 配合工作,所以在JDK1.5中使用CMS来收集老年代时,年轻代只能选择ParNew或者Serial收集器中的一个.

在 G1出现之前,CMS使用非常广泛;

CMS GC执行垃圾回收的过程:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-STruLT59-1634028464288)(.\imgs\CMS垃圾回收过程.jpg)]

CMS的垃圾收集过程可以分为四个主要的阶段：

步骤	具体内容
初始标记阶段	在此阶段，程序的所有的工作线程会因为“Stop-The-World”机制而出现短暂的暂停（此时停顿第一次），这个阶段的主要任务仅仅只是标记出GC Roots能关联到的对象。一旦标记完成，就会恢复之前被暂停的所有的应用线程。由于直接关联的对象比较地小（因为此时在老年代中进行垃圾回收，能被GC Roots标记到的对象很少），所以这里的速度会很快！！
并发标记阶段	从GC Roots的直接关联对象开始遍历整个对象图，这个过程耗时比较长，但是不需要停顿用户线程，可以与垃圾收集收集线程一起并发运行
重新标记阶段	由于在并发标记阶段中，程序的工作线程一一直在运行过程中 ，可能会由于和垃圾的收集线程交叉运行导致之前的一些标记会发生一些变动，故进行标记的修正，这个过程比初始标记略长（STW，此时停顿第二次），但比并发标记的时间要短很多
并发清除阶段	此阶段清理删除掉标记阶段已被判断为已经死亡的对象，并释放内存空间，由于不需要移动内存对象的位置，则此阶段也是可以和用户线程同时并发执行的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iW5xVjfu-1634028464289)(.\imgs\CMS垃圾回收器2.jpg)]

CMS GC的特点：

优点：

1.并发收集垃圾

2.低延迟性

缺点：

1.因为采用的是标记-清除算法，所以会产生内存的碎片；

2.CMS收集器对cpu资源非常地敏感；在并发阶段，它虽然不会导致用户的停顿，但是会占用一部分的线程而导致应用程序变慢，总的吞吐量会降低

3.CMS无法清除浮动垃圾；可能出现“Concurrent Mode Failure”失败而导致另一次Full GC的产生，在并发标记阶段由于程序的工作线程和垃圾收集线程是同时运行或者交叉运行的，那么在并发阶段如何产生了一些新的垃圾对象，此时CMS将无法对这些垃圾进行标记，这些垃圾对象也被称为浮动垃圾，最终导致这些新产生的垃圾对象没有被及时的回收，从而只能在下一次执行GC时释放这些之前未被回收的内存空间。

CMS收集器参数设置:

-XX:+UseConcMarkSweepGC : 手动指定使用CMS垃圾回收器进行内存回收任务
-XX:CMSInitiatingOccupanyFraction : 设置堆内存使用率的阈值,一旦到达该阈值,就会进行垃圾回收
-XX:+UseCMSCompactAtFullCollection : 用于指定在执行完FullGC后对内存空间进行压缩整理,以免避免内存碎片的产生.不过由于内存整理的过程无法并发进行,就会造成停顿时间变长了
-XX:ParallelCMSThreads : 设置CMS的线程数量 

16.7 G1回收器------区域化分代式

G1收集器（Garbage First）： JDK7中引入的垃圾回收器，是目前收集器技术发展的最前沿成果之一；

取名为G1收集器的原因：G1收集器将堆内存分割成很多不相关的区域（region），其物理上是不连续的，使用不同的region来表示Eden区，S0区，S1区老年代等等；G1收集器会跟踪region里面垃圾堆积的价值大小（根据回收所获得的空间大小以及回收所需的时间的经验值等），在后台维护一个优先列表，每次根据允许的收集时间，优先回收价值最大的Region。故由于这种方法侧重于回收垃圾的最大量的区间，所以我们取名为G1 GC。

优点：

1.并发和并行性：并行性表现在G1在回收期间，可以有多个GC线程同时工作，有效的利用多核计算能力，此时用户线程STW；并发性表现在G1拥有和应用程序交替执行的能力，部分工作能够和应用程序同时执行。

2.分代收集：它会区分老年代和新生代，年轻代依旧还是Eden区和Survivor区，但是它并不要整个Eden区，年轻代或者老年代都是连续的，也不坚持固定大小和固定的数量。将堆空间分为了若干个区域，这些区域中包含了逻辑上的年轻代和老年代。但是有一点，它和其他的垃圾收集器都不相同，即它同时可以兼顾年轻代和老年代的垃圾回收。

3.空间的整合：G1将内存划分为一个个的region，内存的回收都是以region为单位进行的，region之间使用的是复制算法，但是整体上使用的是标记-压缩算法，两种算法都是可以避免内存碎片的产生。这种特性有利于程序的长时间的运行，分为大对象时不会因为无法找到连续内存空间而提前触发下一次Full GC。尤其是当java的堆内存非常大的时候，G1的优势会非常地明显。

4.可预测的停顿时间模型：即软实时，G1除了追求低停顿以外，还能建立可预测的停顿时间模型，能让使用者明确指定在一个长度为M毫秒的时间片段中，消耗在垃圾回收的时间不超过N毫秒。

缺点：

1.垃圾收集时产生的内存占用相较于CMS而言，是要高于它的；

2.程序在运行时额外执行负载（OverLoad）也要高于CMS产生的OverLoad

G1 GC的分区(Region)思想:在使用G1垃圾回收器的时候,它将整个java堆划分为了2048个大小相同的独立的Region块,每一个Region块的大小根据堆空间的实际大小而定,整体被控制在1MB到32MB之间,且均为2的N次幂,即1MB,2MB,…,32MB.可以通过-XX:G1HeapRegionSize来设定.所有的Region大小相同,且在JVM生命周期内不可以发生改变.

虽然还保留着新生代和老年代的概念,但是新生代和老年代不再是物理隔离的,他们都是一部分Region(不再连续)的集合,通过Region的动态分配的方式实现了逻辑上的连续

其中:多出了一个H区(Humongous区):

对于堆中的大对象,默认直接会被分配到老年代中,但是如果让是一个短期存在的大对象,就会对垃圾收集器造成负面影响.为了解决这个问题,G1划分了一个Humongous区,它专门用来存放大对象,如果一个H区装不下一个大对象,那么G1会寻找连续的H区来存储.为了能够找到连续的H区,有的时候不得不启动Full GC,G1的大多数行为都是把H区作为老年代的一部分来看待的.

G1收集的三个环节：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yWQzDJPB-1634028464290)(.\imgs\G1垃圾回收过程.jpg)]

1.年轻代GC（YoungGC/MinorGC）: jvm启动的时候，G1会先准备好Eden区，程序在运行过程中，会不断地产生对象到Eden区中，当Eden区的空间耗尽的时候 ，G1会启动一次年轻代垃圾回收过程（YoungGC/MinorGC）：具体回收过程如下所示：

第一步	G1会停止应用程序的执行（Stop The World），G1创建回收集（Collection Set），回收集是指需要被回收的内存分段的集合，年轻代回收过程的回收集包含年轻代Eden区和Survivor区的所有的内存分段
第二步	扫描根：根指的就是GC Roots，根和Rset记录的外部引用作为扫描存活对象的入口
第三步	更新Rset：处理dirty card queue中的card，更新Rset，此阶段结束时，Rset可以准确的反应老年代对所在的内存分段中对象的引用
第四步	处理Rset：识别被老年代指向的Eden区的对象，这些被指向的Eden中的对象被认为是存活的对象
第五步	复制对象：遍历对象树，Eden区中内存段中存活的对象会被复制到Survivor区的空白的内存分段（底层即是复制算法），Survivor区中存活的对象如果年龄未达阈值，则年龄加1，达到阈值则被复制到Old区的空的内存分段，如果Survivor区中内存空间不足。则可以将Eden区中的部分数据直接晋升老年代空间
第六步	处理引用：处理soft,Weak，Phantom，final等引用，最终使得Eden区变空。GC停止工作，因为目标内存中在复制过程中是连续存储的，没有碎片产生，所以复制过程中，可以达到内存整理的效果

注意：上面提到Rset：Remembered Set解释一下其来源和含义

Remembered Set： 因为我们说堆空间被分割成了若干个region，但是每一个region并不是相互独立的，很多时候，一个region里的对象有可能被其他的region里的对象所引用，则我们在扫描过程中寻找存活的对象和已经死亡的对象时，是否需要扫描整个java堆呢？？为了避免全局扫描整个堆区耗费大量的时间，此时引进Rset：即给每个Region分配对应的一个Rset，每次Reference类型数据写操作时，都会产生一个Write Barrier暂时的中断操作，然后检查将要写入的引用指向的对象是否和该Reference类型数据在不同的Region，如果不同，则将相关的引用信息记录到引用指向的对象的Region对应的Rset中，当进行垃圾收集的时候，在GC根节点的枚举范围加入Rset，就可以保证不进行局部扫描，也不会存在遗漏。

2.并发标记过程：

步骤	具体内容
第一步	初始化标记扫描：标记从根节点可以直接可达的对象（STW）
第二步	根区域扫描：G1GC扫描Survivor区可以直接可达的老年代的区域对象，并标记被引用的对象，这一过程必须在YoungGC之前完成
第三步	并发标记：在整个堆中进行并发标记（和应用程序并发执行），若发现区域对象中的所有对象都是垃圾，则这个区域会被立即回收，同时，标记过程中，会计算每个区域中的对象活性（即区域中存活对象的比例）
第四步	再次标记：由于应用程序持续进行，需要进一步修正上一次的标记结果（STW），此阶段中G1采用比CMS更快的初始快照算法
第五步	独占清理：计算各个区域中存活的对象的存活情况和GC回收比例，并进行排序，识别可以混合回收的区域（STW）
第六步	并发清理阶段：识别并清理完全空闲的区域

3.混合回收

当越来越多的对象晋升成老年代时，为了避免堆内存被耗尽，虚拟机会触发一个混合的垃圾收集器，即Mixed GC，该算法除了回收整个Young区，还会回收一部分的Old区。其中，混合回收的回收集包括1/8的老年代内存片段，Eden区片段，Survivor区内存片段。混合回收的算法和年轻代回收的算法完全一致，只是回收集多了老年代的内存片段。

4.Full GC

G1的初衷就是避免Full GC的出现,但是如果上述方式不能正常工作,则G1会停止应用程序的执行(Stop The World),使用单线程的内存回收算法进行垃圾回收,性能会比较差,应用停顿时间比较长;

G1垃圾会收取优化建议:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fuUWG8b5-1634028464291)(.\imgs\G1垃圾回收器4.jpg)]

G1 GC的相关参数设置:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nupWfwxI-1634028464292)(.\imgs\G1垃圾回收器5.jpg)]

16.8 垃圾回收器总结和发展

对比7中经典的垃圾回收器,如下图所示:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1Wu1wf3O-1634028464293)(.\imgs\2020071218043566.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i1nktJ6a-1634028464294)(.\imgs\GC总结1.jpg)]

令人震惊的ZGC!!!未来指日可待!!!
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Pg3dw9Tq-1634028464295)(.\imgs\GC总结2.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5RPKy7Ie-1634028464296)(.\imgs\GC总结3.jpg)]

第十七章 补充面试频繁考点:StringTable

17.1 String的基本特性

String:字符串,使用一对""引起来进行表示

两种实例化的方式:

String str1 = "abc";//字面量的方式
String str2 = new String("ABC");//new对象的方式

String声明为final的,不可以被继承

String实现了Serializable接口:表示字符串是支持序列化的,

​ 实现了Comparable接口:表示String是可以进行比较的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RhMZVwrr-1634028464297)(.\imgs3\123.png)]

String在jdk8即以前内部定义了final char[] value用来存储字符串数据

​ 在jdk9时改成了byte[]

String的基本特性:

1.String代表不可变的字符序列.简称不可变性

​ (1)当对字符串重新赋值时,需要重写指定内存区域赋值,不能使用原有的value进行赋值

 @Test
    public void test01(){
        String s1 = "abc";  //字面量的形式创建的String放在字符串常量池中
        String s2 = "abc";  //字符窗常量池中不会存储相同的字符串
        System.out.println(s1 == s2);//此时两个相同字符串的地址是一样的:true
        s1 = "ABC"; //当对字符串重新赋值时,需要重写指定内存区域赋值,不能使用原有的value进行赋值
        System.out.println(s1 == s2);   //判断两个字符串的地址,此时输出:false
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S1E89Tin-1634028464298)(.\imgs3\String的不可变性1.png)]

​ (2)当对现有的字符串进行连接操作时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值

@Test
    public void test01(){
        String s1 = "abc";  //字面量的形式创建的String放在字符串常量池中
        String s2 = "abc";  //字符窗常量池中不会存储相同的字符串
        s2 = s2 + "def";
        System.out.println(s1);
        System.out.println(s2);
    }
    

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b9LbphJh-1634028464299)(C:\Users\86180\Desktop\jvm笔记\imgs3\String不变性2.png)]

​ (3)当调用String的replace()方法修改指定字符或者字符串时,也需要重新指定内存区域赋值

@Test
    public void test02(){
        String s1 = "abc";
        String s2 = s1.replace("a","m");
        System.out.println(s1);
        System.out.println(s2);
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g6bytilb-1634028464299)(C:\Users\86180\Desktop\jvm笔记\imgs3\String的不可变性3.png)]

2.通过字面量的方式(String str = “sss”;)区别于new的方式(String str2 = new String(“sss”)😉,此时的字符串声明在字符串常量池中.

字符串常量池:jdk7及以后版本在堆空间中,同时注意:字符串常量池是不会存储相同内容的字符串的.

StringPool(字符串常量池):是一个固定大小的HashTable,jdk6默认大小长度为1009,jdk7以后为60013,jdk8以后1009是设置的最小值;如果放进StringPool的String非常多,就会造成Hash冲突严重,从而导致链表会很长,而链表长了以后会造成的影响就是调用String.intern()时性能会大幅度下降.

使用**-XX:StringTableSize**可以设置StringTable的长度

17.2 String的内存分配

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aEeDM0Iv-1634028464300)(.\imgs3\String的内存分配1.png)]

String内存分配演进过程:

1.在jdk6以及以前的版本,字符串常量池存放在永久代中;

2.jdk7中,将字符串常量池进行整改:将字符串常量池的位置放到了Java堆中

​ 所有的字符串都保存在堆中,和其他的普通对象一样,这样你可以在进行调优应用时仅仅需要调整堆的大小了;

​ 字符串常量池概念原本使用得比较多,可以使用String.intern();

3.jdk8中剔除了永久代,引进了元空间,字符串常量池仍然保存在Java堆中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bLXVq1i2-1634028464301)(.\imgs3\6.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nKhhBW8v-1634028464302)(.\imgs3\7.png)]

17.3 String的基本操作

基本操作代码1:

public class StringTest {
    public static void main(String[] args) {
        System.out.println();//2293
        System.out.println("1");//2294
        System.out.println("2");
        System.out.println("3");
        System.out.println("4");
        System.out.println("5");
        System.out.println("6");
        System.out.println("7");
        System.out.println("8");
        System.out.println("9");
        System.out.println("10");//2303
        
        //如下的字符串"1" 到 "10"不会再次加载
        System.out.println("1");//2304
        System.out.println("2");//2304
        System.out.println("3");
        System.out.println("4");
        System.out.println("5");
        System.out.println("6");
        System.out.println("7");
        System.out.println("8");
        System.out.println("9");
        System.out.println("10");//2304
    }
}

基本操作代码2:

class Memory {
    public static void main(String[] args) {//line 1
        int i = 1;//line 2
        Object obj = new Object();//line 3
        Memory mem = new Memory();//line 4
        mem.foo(obj);//line 5
    }//line 9

    private void foo(Object param) {//line 6
        String str = param.toString();//line 7
        System.out.println(str);
    }//line 8
}

对应的内存结构图如下:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qu2NwLP3-1634028464303)(.\imgs3\String基本操作.png)]

18.4 字符串的拼接操作

注意以下要点:

1.字符串常量和字符串常量的拼接的结果在字符串常量池中,原理是编译器优化;

2.常量池中不会存放相同内容的常量

3.只要有一个是变量,结果就会在保存在堆中.变量拼接的原理是StringBuilder;

4.如果拼接的结果调用了intern()方法,则会主动将常量池中还没有的字符串对象放到字符串常量池中,并且返回次对象的地址;

代码1—垃圾斗师:

    @Test
    public void test1(){
        String s1 = "a" + "b" + "c";//编译期优化：等同于"abc"
        String s2 = "abc"; //"abc"一定是放在字符串常量池中，将此地址赋给s2
        /*
         * 最终.java编译成.class,再执行.class
         * String s1 = "abc";
         * String s2 = "abc"
         */
        System.out.println(s1 == s2); //true(既比较值,还比较地址值)
        System.out.println(s1.equals(s2)); //true(只比较值)
    }

代码2—斗王强者

 @Test
    public void test2(){
        String s1 = "javaEE";
        String s2 = "hadoop";
        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";//编译期优化
        //如果拼接符号的前后出现了变量，则相当于在堆空间中new String()，具体的内容为拼接的结果：javaEEhadoop
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;

        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//false
        System.out.println(s3 == s7);//false
        System.out.println(s5 == s6);//false
        System.out.println(s5 == s7);//false
        System.out.println(s6 == s7);//false
        //intern():判断字符串常量池中是否存在javaEEhadoop值，如果存在，则返回常量池中javaEEhadoop的地址；
        //如果字符串常量池中不存在javaEEhadoop，则在常量池中加载一份javaEEhadoop，并返回次对象的地址。
        String s8 = s6.intern();
        System.out.println(s3 == s8);//true
    }

内存结构图如下所示:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IxYBuYos-1634028464304)(.\imgs3\字符串的拼接.png)]

字符串拼接的底层原理剖析:斗皇巅峰

@Test
    public void test3(){
        String s1 = "a";
        String s2 = "b";
        String s3 = "ab";//字符串常量池
        /*
        如下的s4 = s1 + s2 的执行细节：(变量s是我基于底层临时定义的）
        ① StringBuilder s = new StringBuilder();
        ② s.append("a");
        ③ s.append("b");
        ④ s.toString();  --> 约等于 new String("ab"):底层调用了new String("ab"),但是没有往字符串里去存放new的String字符串对象(后面详细讲述)

        补充：在jdk5.0之后使用的是StringBuilder,在jdk5.0之前使用的是StringBuffer
         */
        String s4 = s1 + s2;//
        System.out.println(s3 == s4);//false
    }

用final修饰字符串—则为常量形式!!(斗皇巅峰)

 /*
    1. 字符串拼接操作不一定使用的是StringBuilder!!!
       如果拼接符号左右两边都是字符串常量或常量引用，则仍然使用编译期优化，即非StringBuilder的方式。
    2. 针对于final修饰类、方法、基本数据类型、引用数据类型的量的结构时，能使用上final的时候建议使用上。
     */
    @Test
    public void test4(){
        //此时用final修饰s1和s2,则s1,s2为常量形式
        final String s1 = "a";
        final String s2 = "b";
        String s3 = "ab";
        String s4 = s1 + s2;//此时没有上面利用StringBuilder去创建对象,而是从常量池中拿到s1和s2拼接的结果"ab"
        System.out.println(s3 == s4);//true
    }

注意:通过StringBuilder的append()的api方式去添加字符串的效率远高于使用String字符串拼接方式

因为String字符串拼接方式每次 都会创建StringBuilder,String对象,这样既会浪费时间,还使得内存占用过大,可能导致GC的频繁触发.

18.5 intern()方法------斗宗级别方可入此门

intern()方式的使用------斗宗一星

如果不是用双引号声明的String对象,可以使用String提供的intern()方法:

​ intern()方法会从字符串常量池中查询当前字符串是否存在?

​ (1)如果不存在,就会将当前字符串放到字符串常量池中,返回结果是对应字符串常量池该字符串的地址

​ 比如:String myInfo = new String(“abc”).intern();

​ (2)如果存在,则直接返回对应字符串常量池该字符串的地址

也就是说,如果任意字符串上调用String.intern()方法,那么返回结果所指向的那个类实例,必须和直接以常量形式出现的字符串实例完全相同才行,即如下代码所示:

("a" + "b" + "c").intern() = = "abc";//返回结果true

通俗来讲:intern()方法就是确保字符窗在内存(字符串常量池)中只有一份拷贝!这样可以节约内存空间,加快字符串操作任务的执行速度.

 * 如何保证变量s指向的是字符串常量池中的数据呢？
 * 有两种方式：
 * 方式一： String s = "shkstart";//字面量定义的方式
 * 方式二： 调用intern()
 *         String s = new String("shkstart").intern();
 *         String s = new StringBuilder("shkstart").toString().intern();

new String(“xxx”)到底创建了几个对象?------斗宗五星巅峰

答:两个对象

String s = new String("ab");
会在堆空间中创建两个对象:
一个对象是：new关键字在堆空间创建的
另一个对象是：字符串常量池中的对象"ab"

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8bGkB8sZ-1634028464305)(.\imgs3\new1.png)]

new String(“xxx”) + new String(“yyy”)又会创建几个对象呢?------斗宗九星巅峰

答:5个对象,若深入底层则为6个对象

new String("a") + new String("b")呢？----5个对象
  对象1：new StringBuilder()
  对象2： new String("a")----append添加到StringBuilder
  对象3： 常量池中的"a"
  对象4： new String("b")----append添加到StringBuilder
  对象5： 常量池中的"b"

  深入剖析： StringBuilder的toString():
      对象6 ：new String("ab")
       强调一下，toString()的调用，在字符串常量池中，没有生成"ab"
public class StringNewTest {
    public static void main(String[] args) {
        String str = new String("a") + new String("b");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WuTvAywm-1634028464306)(.\imgs3\new2.png)]

你是否已经准备好了呢?斗尊强者

终结面试题1------斗尊强者

public class StringIntern {
    public static void main(String[] args) {

        String s = new String("1");//创建两个对象:字符串常量池里存放"1"
        s.intern();//调用此方法之前，字符串常量池中已经存在了"1"
        String s2 = "1";
        System.out.println(s == s2);//jdk6：false   jdk7/8：false
--------------------------------------------------------------------------------------------------------------------------------------------------
        String s3 = new String("1") + new String("1");//s3变量记录的地址为：new String("11")
        //执行完上一行代码以后，字符串常量池中，是否存在"11"呢？答案：不存在！！
        s3.intern();//在字符串常量池中生成"11"。
        //jdk6:创建了一个新的对象"11",也就有新的地址。
        //(重点)jdk7/8:此时常量中并没有创建"11",而是创建一个指向堆空间中new String("11")的地址
        String s4 = "11";//s4变量记录的地址：使用的是上一行代码代码执行时，在常量池中生成的"11"的地址
        System.out.println(s3 == s4);//jdk6：false  jdk7/8：true
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ewMFfgCp-1634028464307)(.\imgs3\终极面试题12.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1ZrzTpf3-1634028464309)(.\imgs3\终极面试题1.png)]

注意:以下的面试题版本皆为JDK8(因为上面的JDK太古老了)

终结面试题2------斗尊巅峰

public class StringIntern1 {
    public static void main(String[] args) {
        //StringIntern.java中练习的拓展：
        String s3 = new String("1") + new String("1");//new String("11")
        //执行完上一行代码以后，字符串常量池中，是否存在"11"呢？答案：不存在！！
        String s4 = "11";//在字符串常量池中生成对象"11"
        String s5 = s3.intern();
        System.out.println(s3 == s4);//false
        System.out.println(s5 == s4);//true
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dGCTpmJk-1634028464311)(.\imgs3\终结面试题扩展.png)]

总结:intern()

1.jdk1.6中,将这个字符串对象尝试放入字符串常量池中

​ 如果字符串常量池中有,则不会放入.返回已有的串池中的对象的地址;

​ 如果没有,会把此对象复制一份,放到字符串常量池中,并返回字符串常量池中的对象地址;

2.jdk1.7开始,将这个字符串对象尝试放入字符串常量池中

​ 如果串池中有,则并不会放入,而是返回已有串池的对象的地址

​ 如果没有,则会将对象的引用地址复制一份,放入串池中,并返回串池中的引用地址;

intern()练习------斗圣强者

练习代码1:

public class StringExer1 {
    public static void main(String[] args) {
        String s = new String("a") + new String("b");//new String("ab")
        //在上一行代码执行完以后，字符串常量池中并没有"ab"

        String s2 = s.intern();//jdk6中：在串池中创建一个字符串"ab"
                               //jdk8中：串池中没有创建字符串"ab",而是创建一个引用，指向new String("ab")，将此引用返回

        System.out.println(s2 == "ab");//jdk6:true  jdk8:true
        System.out.println(s == "ab");//jdk6:false  jdk8:true
    }
}

jdk8版本内存结构图:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WTZpFOr9-1634028464313)(.\imgs3\练习1png.png)]

练习代码2:

public class StringExer1 {
    public static void main(String[] args) {
        String x = "ab";//存放在常量池中
        String s = new String("a") + new String("b");//new String("ab")
		
        String s2 = s.intern();//此时常量池中已经存在"ab",直接返回其对象地址给s2
        System.out.println(s2 == x);//true
        System.out.println(s == x);//false
    }
}

内存结构图:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Di0IQ19C-1634028464314)(.\imgs3\练习2.png)]

练习代码3:

public class StringExer2 {
    public static void main(String[] args) {
        
       String s1 = new String("a") + new String("b");执行完以后，不会在字符串常量池中会生成"ab"
        s1.intern();
        String s2 = "ab";
        System.out.println(s1 == s2);//true
    }
}

练习代码4:

public class StringExer2 {
    public static void main(String[] args) {
 
       String s1 = new String("ab");//执行完以后，会在字符串常量池中会生成"ab"
        s1.intern();
        String s2 = "ab";
        System.out.println(s1 == s2);//false
    }
}

总结:

此时此刻,你已经成为斗圣巅峰强者,面试定能反问倒面试官!,再加以修炼,定能冲击斗帝

18. 6 intern其他知识点

intern()的应用场景

使用intern()测试执行效率：空间使用上:对于程序中大量存在存在的字符串，尤其其中存在很多重复字符串时，使用intern()可以节省内存空间

应用场景:大的网站平台.需要内存中存储大量的字符串,比如社交网站,很多人都需要存储类似地址信息,但经常性的这些地址存在很多的相同相似性,这时候如果字符串都调用intern()方法,将会明显地降低内存的大小

public class StringIntern2 {
    static final int MAX_COUNT = 1000 * 10000;
    static final String[] arr = new String[MAX_COUNT];

    public static void main(String[] args) {
        Integer[] data = new Integer[]{1,2,3,4,5,6,7,8,9,10};

        long start = System.currentTimeMillis();
        for (int i = 0; i < MAX_COUNT; i++) {
          //通过两种方式比较可以得出intern()方法对内存的消耗十分地小,节省了大量的内存空间
          //arr[i] = new String(String.valueOf(data[i % data.length]));
            arr[i] = new String(String.valueOf(data[i % data.length])).intern();

        }
        long end = System.currentTimeMillis();
        System.out.println("花费的时间为：" + (end - start));

        try {
            Thread.sleep(1000000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.gc();
    }
}

G1 GC 的String去重操作

​ Java堆中存活的数据集合差不多25%是String对象,其中,里面的差不多一半的String对象都是重复的(即string1.equals(string2) = true);则堆上重复的String对象必然是一种内存的浪费.故在G1垃圾收集器中实现了自动持续对重复的String对象进行去重,这样就能避免浪费内存.

那么是如何实现的呢?

​ 1.当垃圾收集器工作时,会访问堆上存活的对象.对于每一个访问的对象都会检查是否是候选的要去重的String对象

​ 2.如果是,把这个对象的一个引用插入到队列中等待后续的处理.一个去重的线程在后台运行,处理这个队列,处理队列的一个元素意味着从队列中删除这个元素,然后尝试去重它引用的String对象.

​ 3.使用一个hashtable来记录所有的被String对象使用的不重复的char数组.当要去重的时候,会查这个hashtable,来看堆中是否已经存在一个一模一样的char数组;

​ 4.如果存在,String对象会被调整引用那个数组,释放对原来的数组的引用,最终会被垃圾收集器回收掉;

​ 5.如果查找失败,char数组会被插入到hashtable,这样以后就可以共享这个数组了;

可以使用命令行进行String去重的开启:

UseStringDeduplication(bool)

第十八章 JVM大厂面试题

18.1jvm内存结构部分

面试题1:jvm内存分区以及各个区的作用和功能

回答：jvm内存分区分为五个部分:堆区,java虚拟机栈区,本地方法栈,方法区以及程序计数器;

内存结构图如下所示:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-47ZB5c99-1634028464315)(G:\MyDomain\秋招\2021秋招公司面经\imgs\运行时数据区面试题.jpg)]

其中:

程序计数器: 用来存储指向下一条指令的地址,也就是即将执行的指令代码的,并由执行引擎来读取下一条指令

虚拟机栈: 主管java程序的运行,它保存的是方法的局部变量,部分结果,并参与方法的调用和返回。可以这样说，栈解决的是程序的运行问题，即程序如何运行，或者说如何处理数据。每个线程创建时，就会创建一个java虚拟机栈，其内部由一个个的栈帧组成，对应着一次次方法的调用。

本地方法栈: 用来管理本地方法的调用,当某一个线程调用一个本地方法时(别的语言实现的),会进入本地方法栈中处理本地方法的数据，进行本地方法的调用和返回。

堆空间： 堆解决的是数据存储的问题，即数据放在哪里，怎么存放。java堆区在jvm启动时即被创建，是java内存管理的核心区域，几乎所有的对象实例以及数组都存放在堆空间中。

方法区： 方法区用来存储已经被虚拟机加载的类型信息，常量，静态变量，及时编译器（JIT）编译后的代码缓存，域信息，方法信息等（针对JDK1.8及以后版本来说）

面试题2：为什么要有新生代（年轻代）和老年代？

回答：经研究表明，不同对象的生命周期是不相同的，但是70%~99%的对象属于临时对象，将堆区分为新生代和老年代的目的在于优化GC（垃圾回收）的性能，如果不进行分代操作，那么进行GC是会对堆区的所有区域进扫描，而很多对象其实都是“朝生夕死”的，当每次GC都对所有堆区的对象进行扫描回收，将提高GC的时间和降低其效率。但是我们如果分为新生代和老年代，其中新生代存放生命周期较短的对象，即“朝生夕死”或者刚新创建的一些对象，老年代存放生命周期比较长的对象，这样一来进行GC的时候，会先把生命周期较短的临时变量进行回收，不用扫描整个堆区，而是有针对性的进行扫描回收，这样可以节省很多时间和提高回收的效率，大大地提高了jvm的性能。

面试题3：什么时候对象会进入老年代中?

回答：

第一种情况:当对象进入Eden区后经过MinorGC后仍然存活,并且被Survivor区容纳,在接下来的MinorGC中每次都能存活,age依次累加到老年代的阈值(默认为15)后,将其晋升至老年代。

第二种情况:当对象准备从Eden区进入Survivor区中时,发现Survivor无法存放该对象,则进行晋升老年代区

第三种情况:大对象直接分配进入老年代。

第四种情况:动态对象年龄判断:如果Survivor区中的相同年龄的对象大于了Survivor空间的一半,年龄大于或者等该对象年龄的对象可以直接进入老年代,无需等到阈值后进入。

面试题4：jdk8中对jvm的内存结构进行了哪些调整？

JDK8由于Oracle收购了JRockit以后，将HotSpot和JRockit进行了整合，移除了永久代（Permant Generation），引进了元空间（MetaSpace），以下是jdk7和jdk8的jvm内存结构图：

而对于jvm，主要的变动就在于方法区内存的改变，此处列出JDK6及之前版本，JDK7和JDK8三种不同版本的改变：

图示如下所示：

JDK6及之前的版本的方法区：

JDK7版本的方法区：

JDK8的方法区：

面试题5：jvm的永久代、元空间会发生垃圾回收吗？

回答：永久代、元空间是会发生垃圾回收的！首先我们说一下在方法区中，java虚拟机规范中对方法区的约束是比较宽松的，提到可以不要求虚拟机在方法区进行垃圾回收。但是这部分区域的回收是很有必要的，其中方法区的垃圾回收主要包括两个方面：常量池中的废弃的常量和再使用的类型。

常量池中主要存放的是：字面量和符号的引用。其中字面量比较接近java语言层次的常量的概念，例如：文本字符串，被声明final的常量值等等，而符号的引用主要包括以下三类常量：

1.类和接口的全限定名

2.字段的名称和描述符

3.方法的名称和描述符

HotSpot虚拟机对于常量池中回收策略很明确：只要常量池中的常量没有被任何地方引用，就可以被回收！！

但是判断一个类型是否属于“不再被使用的类”的条件十分的苛刻！！

首先需要满足一下三个条件

1.该类的所有的实例都已经被回收，也就是java堆中不存在该类以及其任何派生子类的实例；

2.加载该类到的类加载器已经被回收

3.该类对应的java.lang.Class对象没有任何地方被引用，无法在任何地方通过反射访问该类的方法；

但是，java虚拟机被允许的对满足上面满足上述三中情况的无用类进行回收，仅仅是允许而已。

面试题6：jdk8什么会将永久代改变成元空间呢？

回答：由于永久代存在着很多的弊端：

1.为永久代设置空间大小是很困难的；某些场景下，如果动态加载的类过多，容易产生Perm区的OOM。而元空间和永久代最大的区别在于：元空间并不在虚拟机中，而是使用的本地的内存，因此，默认情况下，元空间的大小仅仅受到本地内存的限制。

2.对永久代进行性能的调优是很困难的；如果采用永久代，则内存不足并不可少会触发Full GC，但这样会造成应用程序线程的停顿时间过长，对于性能是有很大的弊端的，而且对于Full GC，我们并不能进行多大程度的性能调优，而采用元空间，直接使用的就是本地的内存，则很大程度上的避免Full GC的发生。

面试题7: StringTable为什么要被调整?

18.2.jvm垃圾收集器部分

面试题1:什么内存需要进行GC?什么时候进行GC?如何进行GC?

回答:

什么内存需要进行GC？

在一个程序运行过程中,如果一个对象,没有任何指针指向它,则说明该对象成为一种垃圾,该对象所占的内存即为需要进行GC的内存。

什么时候进行GC？什么时候会触发垃圾回收？

一般来说，垃圾回收是针对堆区进行的，而堆区主要是针对新生代和老年代的垃圾的回收，当新生代的内存被填满时，会触发新生代（年轻代）垃圾回收器进行垃圾回收，而当新生代中持续存在的对象到达阈值年龄以后或者大对象新生代无法直接存下的时候，会直接存放到老年代中，而老年代的内存空间被填满后，会触发老年代垃圾回收器进行垃圾的回收。如果老年代回收器进行垃圾回收以后，内存依旧不足，则此时会触发FullGC，如果进行FullGC以后还是内存不足，此时就会报OutOfMemoryError(OOM)-----内存溢出异常。

如何进行GC？

面试题2:jvm的GC的相关算法有哪些？目前jdk版本采用什么算法？

回答：

jvm的GC的算法分为两个阶段：垃圾标记阶段和垃圾清除阶段

垃圾标记阶段的算法：主要有引用计数算法和可达性分析算法（或者称为根搜索算法，追踪性垃圾收集算法）；

垃圾清除阶段的算法：主要有标记-清除算法，复制算法，标记-压缩（整理）算法；

其中目前jdk8中主要标记阶段使用的是可达性分析算法，而清除阶段，因为jdk8默认的垃圾回收器是ParalleGC，而其内部采用的是复制算法（进行新生代的垃圾回收），与其组合搭配使用的Serial Old GC和Parallel Old GC 采用标记-压缩算法。

面试题3：GC是什么？为什么会有GC？

回答：

GC：Garbage Collection（垃圾回收）

在我们的程序运行过程中，会产生许多的垃圾对象（即在一个程序运行过程中,如果一个对象,没有任何指针指向它,则说明该对象成为一种垃圾），如果不及时进对内存中的垃圾进行清理，那么垃圾对象所占的内存空间会一直保留到应用程序结束，被保留的内存空间就无法被其他的对象所使用，甚至会导致内存的泄露。

面试题4：GC的两种判定方法是什么？

回答：

对象是否死亡的2种判定方法：引用计数和可达性分析（又称引用链），即所谓的两种垃圾的标记算法

1.引用计数

    每个对象被创建的时候，jvm会为每一个对象的对象头保存一个引用计数引用，来记录该对象被引用的情况：当该对象被任意对象引用时，计数器+1；引用失效，计数器 －1；GC时会回收计数器为0的对象。注意：该方式无法解决对象互相循环引用的情况，java垃圾回收器没有采用判定方式

2.引用链（可达性分析）

    程序把所有的引用看作图（类似树结构的图），选定一个对象作为GC Root根节点，从该节点开始寻找对应的引用节点并标记，找到这个节点之后，继续寻找这个节点的引用节点，当所有的引用节点寻找完毕之后，剩余的节点认为是不可达的无用节点，会被回收。
    
    该方式可以解决循环引用的问题；
    GC Roots：指的是一组必须活跃的引用   
    通常情况下，包括以下几种：  
    1.虚拟机栈中被引用的对象；比如各个线程中使用到的参数，局部变量等等 
    2.本地方法栈中的JNI引用的对象 
    3.方法区中类静态属性引用的对象 
    4.方法区中字符串常量池中的对象 
    5.所有被同步锁synchronized持有的对象 
    6.java虚拟机的内部引用

总之，是处于堆外的活跃的对象引用

但是，注意，有的时候，当用户选择的 垃圾回收以及垃圾回收的内存区域不同的时候，我们还可以选择其他的对象作为“临时性GC Roots”加入，其中，我们说对新生代进行垃圾回收时,此时的老年代活跃的对象可以作为GC Roots集合的一份子。

面试题5：分别讲述一下CMS收集器和G1收集器

回答：

CMS收集器（Concurrent-Mark-Sweep） ：是jdk1.5的时候提出的，它是HotSpot虚拟机中第一款真正意义上的并发垃圾收集器，它第一次实现了让垃圾收集线程和用户线程同时运行。CMS是一款老年代的收集器，与其新生代搭配使用的垃圾收集器是ParNewGC和Serial GC的一个。当CMS运行期间发生预留的内存无法满足程序的需要，此时会出现“Concurrent Mode Failure”失败，此时，虚拟机会启动后备方案，即启用serial Old GC重新进行老年代的垃圾回收。

版本变动：其中在JDK8版本中将CMS-Serial GC的组合声明为弃用状态，在JDK9中移除。在

JDK14中，删除了CMS垃圾回收器。采用的是标记-清除算法。

CMS的垃圾收集过程可以分为四个主要的阶段：

步骤	具体内容
初始标记阶段	在此阶段，程序的所有的工作线程会因为“Stop-The-World”机制而出现短暂的暂停（此时停顿第一次），这个阶段的主要任务仅仅只是标记出GC Roots能关联到的对象。一旦标记完成，就会恢复之前被暂停的所有的应用线程。由于直接关联的对象比较地小（因为此时在老年代中进行垃圾回收，能被GC Roots标记到的对象很少），所以这里的速度会很快！！
并发标记阶段	从GC Roots的直接关联对象开始遍历整个对象图，这个过程耗时比较长，但是不需要停顿用户线程，可以与垃圾收集收集线程一起并发运行
重新标记阶段	由于在并发标记阶段中，程序的工作线程一一直在运行过程中 ，可能会由于和垃圾的收集线程交叉运行导致之前的一些标记会发生一些变动，故进行标记的修正，这个过程比初始标记略长（STW，此时停顿第二次），但比并发标记的时间要短很多
并发清除阶段	此阶段清理删除掉标记阶段已被判断为已经死亡的对象，并释放内存空间，由于不需要移动内存对象的位置，则此阶段也是可以和用户线程同时并发执行的

CMS GC的特点：

优点：

1.并发收集垃圾

2.低延迟性

缺点：

1.因为采用的是标记-清除算法，所以会产生内存的碎片；

2.CMS收集器对cpu资源非常地敏感；在并发阶段，它虽然不会导致用户的停顿，但是会占用一部分的线程而导致应用程序变慢，总的吞吐量会降低

3.CMS无法清除浮动垃圾；可能出现“Concurrent Mode Failure”失败而导致另一次Full GC的产生，在并发标记阶段由于程序的工作线程和垃圾收集线程是同时运行或者交叉运行的，那么在并发阶段如何产生了一些新的垃圾对象，此时CMS将无法对这些垃圾进行标记，这些垃圾对象也被称为浮动垃圾，最终导致这些新产生的垃圾对象没有被及时的回收，从而只能在下一次执行GC时释放这些之前未被回收的内存空间。

G1收集器（Garbage First）： JDK7中引入的垃圾回收器，是目前收集器技术发展的最前沿成果之一；

取名为G1收集器的原因：G1收集器将堆内存分割成很多不相关的区域（region），其物理上是不连续的，使用不同的region来表示Eden区，S0区，S1区老年代等等；G1收集器会跟踪region里面垃圾堆积的价值大小（根据回收所获得的空间大小以及回收所需的时间的经验值等），在后台维护一个优先列表，每次根据允许的收集时间，优先回收价值最大的Region。故由于这种方法侧重于回收垃圾的最大量的区间，所以我们取名为G1 GC。

优点：

1.并发和并行性：并行性表现在G1在回收期间，可以由多个GC线程同时工作，有效的利用多核计算能力，此时用户线程STW；并发性表现在G1拥有和应用程序交替执行的能力，部分工作能够和应用程序同时执行。

2.分代收集：它会区分老年代和新生代，年轻代依旧还是Eden区和Survivor区，但是它并不要整个Eden区，年轻代或者老年代都是连续的，也不坚持固定大小和固定的数量。将堆空间分为了若干个区域，这些区域中包含了逻辑上的年轻代和老年代。但是有一点，它和其他的垃圾收集器都不相同，即它同时可以兼顾年轻代和老年代的垃圾回收。

3.空间的整合：G1将内存划分为一个个的region，内存的回收都是以region为单位进行的，region之间使用的是复制算法，但是整体上使用的是标记-压缩算法，两种算法都是可以避免内存碎片的产生。这种特性有利于程序的长时间的运行，分为大对象时不会因为无法找到连续内存空间而提前触发下一次Full GC。尤其是当java的堆内存非常大的时候，G1的优势会非常地明显。

4.可预测的停顿时间模型：即软实时，G1除了追求低停顿以外，还能建立可预测的停顿时间模型，能让使用者明确指定在一个长度为M毫秒的时间片段中，消耗在垃圾回收的时间不超过N毫秒。

缺点：

1.垃圾收集时产生的内存占用相较于CMS而言，是要高于它的；

2.程序在运行时额外执行负载（OverLoad）也要高于CMS产生的OverLoad

G1收集的三个环节：

1.年轻代GC（YoungGC/MinorGC）: jvm启动的时候，G1会先准备好Eden区，程序在运行过程中，会不断地产生对象到Eden区中，当Eden区的空间耗尽的时候 ，G1会启动一次年轻代垃圾回收过程（YoungGC/MinorGC）：具体回收过程如下所示：

第一步	G1会停止应用程序的执行（Stop The World），G1创建回收集（Collection Set），回收集是指需要被回收的内存分段的集合，年轻代回收过程的回收集包含年轻代Eden区和Survivor区的所有的内存分段
第二步	扫描根：根指的就是GC Roots，根和Rset记录的外部引用作为扫描存活对象的入口
第三步	更新Rset：处理dirty card queue中的card，更新Rset，此阶段结束时，Rset可以准确的反应老年代对所在的内存分段中对象的引用
第四步	处理Rset：识别被老年代指向的Eden区的对象，这些被指向的Eden中的对象被认为是存活的对象
第五步	复制对象：遍历对象树，Eden区中内存段中存活的对象会被复制到Survivor区的空白的内存分段（底层即是复制算法），Survivor区中存活的对象如果年龄未达阈值，则年龄加1，达到阈值则被复制到Old区的空的内存分段，如果Survivor区中内存空间不足。则可以将Eden区中的部分数据直接晋升老年代空间
第六步	处理引用：处理soft,Weak，Phantom，final等引用，最终使得Eden区变空。GC停止工作，因为目标内存中在复制过程中是连续存储的，没有碎片产生，所以复制过程中，可以达到内存整理的效果

注意：上面提到Rset：Remembered Set解释一下其来源和含义

Remembered Set： 因为我们说堆空间被分割成了若干个region，但是每一个region并不是相互独立的，很多时候，一个region里的对象有可能被其他的region里的对象所引用，则我们在扫描过程中寻找存活的对象和已经死亡的对象时，是否需要扫描整个java堆呢？？为了避免全局扫描整个堆区耗费大量的时间，此时引进Rset：即给每个Region分配对应的一个Rset，每次Reference类型数据写操作时，都会产生一个Write Barrier暂时的中断操作，然后检查将要写入的引用指向的对象是否和该Reference类型数据在不同的Region，如果不同，则将相关的引用信息记录到引用指向的对象的Region对应的Rset中，当进行垃圾收集的时候，在GC根节点的枚举范围加入Rset，就可以保证不进行局部扫描，也不会存在遗漏。

2.并发标记过程：

步骤	具体内容
第一步	初始化标记扫描：标记从根节点可以直接可达的对象（STW）
第二步	根区域扫描：G1GC扫描Survivor区可以直接可达的老年代的区域对象，并标记被引用的对象，这一过程必须在YoungGC之前完成
第三步	并发标记：在整个堆中进行并发标记（和应用程序并发执行），若发现区域对象中的所有对象都是垃圾，则这个区域会被立即回收，同时，标记过程中，会计算每个区域中的对象活性（即区域中存活对象的比例）
第四步	再次标记：由于应用程序持续进行，需要进一步修正上一次的标记结果（STW），此阶段中G1采用比CMS更快的初始快照算法
第五步	独占清理：计算各个区域中存活的对象的存活情况和GC回收比例，并进行排序，识别可以混合回收的区域（STW）
第六步	并发清理阶段：识别并清理完全空闲的区域

3.混合回收

当越来越多的对象晋升成老年代时，为了避免堆内存被耗尽，虚拟机会触发一个混合的垃圾收集器，即Mixed GC，该算法除了回收真个Young区，还会回收一部分的Old区。其中，混合回收的回收集包括1/8的老年代内存片段，Eden区片段，Survivor区内存片段。混合回收的算法和年轻代回收的算法完全一致，只是回收集多了老年代的内存片段。

4.Full GC

G1的初衷就是避免Full GC的出现,但是如果上述方式不能正常工作,则G1会停止应用程序的执行(Stop The World),使用单线程的内存回收算法进行垃圾回收,性能会比较差,应用停顿时间比较长;

面试题6：常用的垃圾回收器有哪些？各有什么优缺点

面试题7：分代回收讲解一下

回答：目前几乎所有的GC都是采用分代回收的，即Generational Collecting算法执行垃圾回收的。

jvm中使用的HotSpot基于分代的概念，GC所使用的的内存回收算法必须要结合年轻代和老年代各自的特点：

分区	分区的特点
年轻代/新生代	区域相对于老年代较小，对象的生命周期较短，存活率低，回收频繁。这种情况复制算法的回收整理，速度是最快的。复制算法的效率只和当前存活的对象大小有关，因此很适用于年轻代的垃圾回收。而复制算法内存利用率不高的问题，可以通过HotSpot中的两个Survivor区来进行缓解
老年代	老年代的区域很大，对象生命周期很长，存活率高，回收不及年轻代频繁。这种情况下存在大量存活率高的对象，复制算法就明显变得不合适。一般情况下我们采用标记-清除或者标记-整理的算法的混合实现

如此一来，我们针对堆空间的分代（新生代和老年代）分别进行垃圾的回收，可以大面积提高垃圾回收的效率，减少不必要的停顿时间（Stop-The-World）。

面试题8：常见的垃圾回收的算法有哪些？如何选择这些垃圾回收算法？各有什么优缺点？

常见的垃圾回收算法有标记-清除算法，复制算法，标记-压缩（整理）算法，下面列表比较一下这三种算法的优缺点

垃圾回收算法	工作流程	优点	缺点
标记-清除算法（Mark-Sweep）	当堆中的有效空间被耗尽时，会停顿整个程序（STW），进行标记（即从引用节点开始遍历，标记所有被引用的对象），然后对堆内存进行一次线性的遍历，对于对象头中没有标记可达的对象，进行回收。	简单直接	效率不高；进行GC的时候回暂停整个应用程序，用户的体验感不好；这种清理方式清理出来的内存空间不是连续的，产生内存碎片，则需要维护一个空闲列表。
复制算法（Copying）	为了解决上面标记-清除算法产生的内存碎片应运而生，将活着的内存空间分为两块，每次只使用其中一块空间，在垃圾回收时，在垃圾回收时将正在使用的内存中的存活对象复制到未使用的内存块中，之后清除正在使用的内存块中所有对象，交换两个内存的角色，最后完成垃圾回收。	没有标记和清除过程，实现简单，运行高效；复制过去以后可以保证空间的连续性，不会出现碎片问题	此算法需要使用内存的两倍的空间，对内存空间的需求量比较大；对于G1这种分区的GC，复制而不是移动，意味着GC需要维护region之间的对象的引用关系，不管是内存的占用还是时间开销方面。
标记-压缩算法（Mark-Compact）	第一阶段和标记-清除算法一样，从根节点开始标记所有被引用的对象；然后第二阶段将所有存活的对象压缩到内存的一=端，按照顺序进行排放，之后再清理边界外的所有的空间。	消除了标记-清除算法中内存区域分散的缺点，我们需要给新对象分配内存时，jvm只需要持有一个内存的起始地址即可；消除了复制算法当中，内存减半的高额代价。	效率上来说低于复制算法；移动对象时，如果对象被其他对象引用，需要调整引用的地址；移动过程中，需要暂停用户的应用程序（STW）

| 并发标记：在整个堆中进行并发标记（和应用程序并发执行），若发现区域对象中的所有对象都是垃圾，则这个区域会被立即回收，同时，标记过程中，会计算每个区域中的对象活性（即区域中存活对象的比例） |
| 第四步 | 再次标记：由于应用程序持续进行，需要进一步修正上一次的标记结果（STW），此阶段中G1采用比CMS更快的初始快照算法 |
| 第五步 | 独占清理：计算各个区域中存活的对象的存活情况和GC回收比例，并进行排序，识别可以混合回收的区域（STW） |
| 第六步 | 并发清理阶段：识别并清理完全空闲的区域 |

3.混合回收

当越来越多的对象晋升成老年代时，为了避免堆内存被耗尽，虚拟机会触发一个混合的垃圾收集器，即Mixed GC，该算法除了回收真个Young区，还会回收一部分的Old区。其中，混合回收的回收集包括1/8的老年代内存片段，Eden区片段，Survivor区内存片段。混合回收的算法和年轻代回收的算法完全一致，只是回收集多了老年代的内存片段。

4.Full GC

G1的初衷就是避免Full GC的出现,但是如果上述方式不能正常工作,则G1会停止应用程序的执行(Stop The World),使用单线程的内存回收算法进行垃圾回收,性能会比较差,应用停顿时间比较长;

面试题6：常用的垃圾回收器有哪些？各有什么优缺点

面试题7：分代回收讲解一下

回答：目前几乎所有的GC都是采用分代回收的，即Generational Collecting算法执行垃圾回收的。

jvm中使用的HotSpot基于分代的概念，GC所使用的的内存回收算法必须要结合年轻代和老年代各自的特点：

分区	分区的特点
年轻代/新生代	区域相对于老年代较小，对象的生命周期较短，存活率低，回收频繁。这种情况复制算法的回收整理，速度是最快的。复制算法的效率只和当前存活的对象大小有关，因此很适用于年轻代的垃圾回收。而复制算法内存利用率不高的问题，可以通过HotSpot中的两个Survivor区来进行缓解
老年代	老年代的区域很大，对象生命周期很长，存活率高，回收不及年轻代频繁。这种情况下存在大量存活率高的对象，复制算法就明显变得不合适。一般情况下我们采用标记-清除或者标记-整理的算法的混合实现

如此一来，我们针对堆空间的分代（新生代和老年代）分别进行垃圾的回收，可以大面积提高垃圾回收的效率，减少不必要的停顿时间（Stop-The-World）。

面试题8：常见的垃圾回收的算法有哪些？如何选择这些垃圾回收算法？各有什么优缺点？

常见的垃圾回收算法有标记-清除算法，复制算法，标记-压缩（整理）算法，下面列表比较一下这三种算法的优缺点

垃圾回收算法	工作流程	优点	缺点
标记-清除算法（Mark-Sweep）	当堆中的有效空间被耗尽时，会停顿整个程序（STW），进行标记（即从引用节点开始遍历，标记所有被引用的对象），然后对堆内存进行一次线性的遍历，对于对象头中没有标记可达的对象，进行回收。	简单直接	效率不高；进行GC的时候回暂停整个应用程序，用户的体验感不好；这种清理方式清理出来的内存空间不是连续的，产生内存碎片，则需要维护一个空闲列表。
复制算法（Copying）	为了解决上面标记-清除算法产生的内存碎片应运而生，将活着的内存空间分为两块，每次只使用其中一块空间，在垃圾回收时，在垃圾回收时将正在使用的内存中的存活对象复制到未使用的内存块中，之后清除正在使用的内存块中所有对象，交换两个内存的角色，最后完成垃圾回收。	没有标记和清除过程，实现简单，运行高效；复制过去以后可以保证空间的连续性，不会出现碎片问题	此算法需要使用内存的两倍的空间，对内存空间的需求量比较大；对于G1这种分区的GC，复制而不是移动，意味着GC需要维护region之间的对象的引用关系，不管是内存的占用还是时间开销方面。
标记-压缩算法（Mark-Compact）	第一阶段和标记-清除算法一样，从根节点开始标记所有被引用的对象；然后第二阶段将所有存活的对象压缩到内存的一=端，按照顺序进行排放，之后再清理边界外的所有的空间。	消除了标记-清除算法中内存区域分散的缺点，我们需要给新对象分配内存时，jvm只需要持有一个内存的起始地址即可；消除了复制算法当中，内存减半的高额代价。	效率上来说低于复制算法；移动对象时，如果对象被其他对象引用，需要调整引用的地址；移动过程中，需要暂停用户的应用程序（STW）

选择哪种垃圾算法，还是要针对不同的应用场景来说，当我们对新生代、年轻代进行垃圾回收时，可以优先考虑复制算法，因为新生代中大部分的对象都是生命周期很短的，朝生夕死的对象，使用复制算法可以提高回收的效率，同时由于存活的需要复制的对象很少，则大大地发挥了此算法的优势。而对于老年代这种生命周期较长的区域，我们则优先考虑标记-清除和标记-压缩（整理）的结合。