文章目录

1 JVM与Java体系结构
- 1.0 Java发展重大事件
- 1.1 虚拟机和Java虚拟机
- 1.3 JVM整体结构
- 1.4 Java代码执行流程
- 1.5 JVM架构模型
- 1.6 JVM的生命周期
- 1.7 JVM发展历程
2 类加载子系统
- 2.1 ClassLoader
- 2.2 用户自定义类加载器
- - 2.2.1 为什么需要自定义类加载器
  - 2.2.2 自定义类加载器的实现步骤
- 2.3 双亲委派机制
- 2.3 类的加载过程
- 2.4 其他
3 运行时区域
- 3.1 本地方法栈
- 3.2 程序计数器
- 3.3 方法区
- - 3.3.1 Hotspot中方法区的演进
  - 3.3.2 设置方法区内存大小
- 3.4 栈
- - 3.4.1 几个面试题
- 3.5 堆
- - 3.5.1 Minor GC、Major GC和Full GC
  - 3.5.2 使用分代思想的原因
  - 3.5.3 内存分配策略
  - 3.5.4 TLAB
  - 3.5.5 堆是不是分配对象存储的唯一选择
参考材料

1 JVM与Java体系结构

1.0 Java发展重大事件

2000年，JDK 1.3发布，Java Hot Spot Virtual Machine正式发布，成为Java的默认虚拟机。
2006年，JDK 6发布。同年，Java开源并建立了OpenJDK。顺理成章，Hotspot虚拟机也成为了OpenJDK中的默认虚拟机。
2008年，Oracle收购了BEA，得到了JRockit虚拟机。
2010年，Oracle收购了Sun，获得了Java的商标和HotSpot虚拟机。
2011年，JDK 7 中正式启用G1垃圾收集器。
2017年，JDK 9 中G1成为默认的GC，代替CMS。IBM也开源了J9 虚拟机。
2018年，JDK 11 LTS版本，发布革命性的ZGC，调整jdk授权许可。
2019年， JDK 12发布，增加了Shenandoah gc。

1.1 虚拟机和Java虚拟机

虚拟机，就是虚拟的计算机，是用来执行一系列虚拟计算机指令的软件。大体可以分为系统虚拟机和程序虚拟机。

Visual Box，VMWare就是系统虚拟机，它们完全是对物理计算机的仿真，提供了一个可运行的完整的操作系统软件平台。 Java虚拟机就是典型的程序虚拟机，它专门为执行单个计算机程序而设计。

无论是哪种虚拟机，其上所运行的软件都被限制于虚拟机提供的资源中。

Java虚拟机就是一台执行字节码（这个字节码可以是Java语言生成的，也可以是其他语言生成的）的虚拟计算机。

在这里插入图片描述

1.3 JVM整体结构

在这里插入图片描述

1.4 Java代码执行流程

java源码（xxx.java）
编译（前端编译）：词法分析、语法分析、语法/抽象语法树、语义分析、注解抽象语法树和字节码生成器。
字节码（xxx.class）
Java虚拟机：类加载器，字节码校验器，字节码解释器和JIT编译器
二进制指令
操作系统

1.5 JVM架构模型

Java编译器输入的指令流基本上是一种基于栈的指令集架构，另外一种指令架构是基于寄存器的指令架构。
栈式架构特点：

设计和实现更简单，适用于资源受限的系统。
避开了寄存器分配难题：使用零地址指令方式分配。
指令流中的指令大部分是零地址指令，其执行过程依赖于操作栈。指令集更小(单条指令更短)，编译器容易实现。
不需要硬件支持，可移植性更好，更好实现跨平台。

寄存器式架构特点：
5. 典型应用是x86的二进制指令集：传统pc以及Android的Davlik虚拟机。
6. 指令集架构完全依赖硬件，可移植性差。
7. 性能优秀和执行高效。
8. 花费更少的指令（指令条数少）去完成一项操作。
9. 大部分情况下，基于寄存器架构的指令集往往都以一地址指令、二地址指令和三地址指令为主。基于栈的指令架构往往以零地址指令为主。

举例：两种指令架构下实现2+3

iconst_2  // 常量2入栈
istore_1
iconst_3 // 常量3入栈
istore_2
iload_1
iload_2
iadd // 常量2,3出栈，执行相加
istore_0  // 结果5入栈

mov eax,2 // eax 初始值设置为2
add eax，3 // 将寄存器内的值+3

1.6 JVM的生命周期

【启动】
Java虚拟机的启动是通过引导类加载器（Bootstrap class loader）创建一个初始类（initial class）来完成的，这个类由虚拟机的具体实现指定的。
【执行】
一个运行中的Java虚拟机有一个清晰的任务：执行java程序。
程序开始执行时它才运行，程序结束时它就停止。
执行一个Java程序的时候，真正执行的是一个Java虚拟机的进程。
【退出】

程序正常执行结束
程序在执行过程中遇到了异常或者错误而异常终止
由于操作系统出现错误而导致Java虚拟机进程终止。
某线程调用Runtime类或者System类的exit方法，或者调用Runtime类的halt方法，并且Java安全管理器也允许这次exit或者halt操作。
JNI规范描述了用JNI Invocation API来加载或者卸载Java虚拟机时，Java虚拟机退出。

1.7 JVM发展历程

【Sun Classic VM】
1996年，JDK1.0发布了第一款商用的java虚拟机，Sun Classic VM。jdk 1.4的时候被淘汰掉了。
此VM只提供解释器。
如果要使用jit编译器，需要进行外挂。一旦使用了JIT，JIT就会接管虚拟机的执行系统。解释器就不再工作。解释器和编译器不能配合工作。
现在HotSpot虚拟机中内置了此虚拟机。

【Exact VM】

jdk1.2时提供了此虚拟机。
Exact Memory Management：准确式内存管理。虚拟机可以知道内存中某个位置的数据具体是什么类型。
具备现代高性能虚拟机的雏形：（1）热点探测（2）编译器与解释器的混合工作模式。
只在Solaris平台短暂使用过。最终被Hotspot取代。

【HotSpot VM】

jdk1.3的时候成为了默认的虚拟机。
占有绝对的市场地位，称霸武林。 Oracle jdk和OpenJDK中都是默认的虚拟机。
使用热点探测技术。通过计数器找到最有编译价值的代码，触发即时编译或者栈上替换。通过编译器和解释器协同工作，在最优化响应时间和最佳执行性能中取得平衡。

【JRockit VM】

专注于服务端应用。不关注启动速度，内部不包含解释器，全部代码依靠即时编译器编译后执行。
最快的JVM

【J9】

IBM公司所有
号称是最快的虚拟机。主要是在IBM的产品上使用效果比较好。

【Azul VM】

与特定硬件平台绑定，软硬件配合的专有虚拟机。
每个Azul VM实例都可以管理至少数十个CPU和数百个GB内存的硬件资源，并提供在巨大的内存范围内实现可控的GC时间的垃圾收集器、专有硬件优化的线程调度等优秀特征。

【Liquid VM】

与特定硬件平台绑定，软硬件配合的专有虚拟机。
Liquid VM不需要操作系统的支持，或者说它本身实现了一个专用操作系统的必要功能，如线程调度、文件系统和网络支持等。

【Apache Harmony】

它的Java类库代码被吸收进了Android SDK中。

【Micorsoft JVM】

初衷是为了在IE浏览器中支持Java Applets，只能在windows平台下运行，是当时windows平台下性能最好的Java VM
1997年，因为侵犯商标，不正当竞争等罪名，此VM下架了。

【TaobaoJVM】

阿里基于OpenJDK开发了自己定制化的AlibabaJDK
是深度定制且开源的高性能服务器版的Java虚拟机。
GCIH（GC Invisible heap）技术实现了off-heap，即将生命周期较长的Java对象从heap中搬移到heap之外，并且GC不能管理GCIH内部的Java对象，以此达到降低GC回收频率和提升GC的回收效率的目的。
GCIH中的对象能够在多个虚拟机进程中实现共享。
严重依赖intel的cpu，损失了兼容性，提高了性能。

【Dalvik VM】

Goolge开发的，应用于Android系统，并在Android2.2中提供了JIT
Dalvik VM只能称为虚拟机，不能称为“Java虚拟机”，它没有遵循Java虚拟机规范。
执行的是dex（Dalvik Executable）文件，效率较高。dex文件可以通过classes文件转化而来。
基于寄存器的指令架构
Android 5.0使用支持提前编译（Ahead of Time Compilation， AOT）的ART VM替换掉Dalvik VM。

【Graal VM】

2018.04 Oracle Labs公开
Run Programmes Faster Anywhere
跨语言全栈虚拟机，可以作为“任何语言”的运行平台。包括c和cpp。

2 类加载子系统

2.1 ClassLoader

在这里插入图片描述
ClassLoader是可以有多个的。

文件头特定的文件标识就是“咖啡baby”。
在这里插入图片描述

所有的类加载器不是继承关系，可以看做是等级关系，永远都是最高等级的bootstrap先加载对象，其加载不了的才轮到后面。

【Bootstrap类加载器】
bootstrap加载器加载jre/lib/rt.jar，resources.jar或者sun.boot.class.path路径中的内容，Object类，String类，ArrayList等都是其加载的。
查看启动类加载器的加载路径

URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();

加载扩展类和应用程序类加载器，并指定为他们的父类加载器。
出于安全考虑，Bootstrap启动类加载器只加载包名为java、javax、sun等开头的类。

【Ext类加载器】
扩展类加载器加载的是 jre/lib/ext/*.jar中的内容。
如果用户创建jar包也放在了ext目录中, 也会自动由ext类加载器进行加载。

查看扩展类加载器的加载路径

String extDirs = System.getProperty("java.ext.dirs");
String dirArr = extDirs.split(";");

【系统类加载器】
应用程序类加载器加载Java编码中自定义的对象。
负责加载环境变量classpath或者系统属性java.class.path指定路径下的类库。
系统类加载器是程序中默认的类加载器，一般来说，Java应用的类都有它来完成。
可以通过如下方式获取到此类加载器：ClassLoader.getSystemClassLoader()

验证用例程序

package org.example.classloader;

import com.sun.nio.zipfs.JarFileSystemProvider;

public class ClassLoaderTest {
    public static void main(String[] args) {
        Object o = new Object();
        System.out.println(o.getClass().getClassLoader()); // bootstrap class loader 获得不到的，返回值为null

        System.out.println("==========================================");

        MyObject myObject = new MyObject();
        System.out.println(myObject.getClass().getClassLoader());
        System.out.println(myObject.getClass().getClassLoader().getParent());
        System.out.println(myObject.getClass().getClassLoader().getParent().getParent());

        System.out.println("==========================================");

        JarFileSystemProvider provider = new JarFileSystemProvider();
        System.out.println(provider.getClass().getClassLoader());
        System.out.println(provider.getClass().getClassLoader().getParent());
    }
}

class MyObject {

}


null
==========================================
sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@14ae5a5
null
==========================================
sun.misc.Launcher$ExtClassLoader@14ae5a5
null

从JVM规范的角度上讲，类加载器分为两种：引导类加载器（Bootstrap ClassLoader）和自定义类加载器（User-defined ClassLoader）。Java虚拟机规范中将所有的派生于ClassLoader的类加载器全部划归为自定义类加载器。

获取classLoader的方式：

获取一个类的ClassLoader

clazz.getClassLoader();

获取当前线程上下文的ClassLoader

Thread.currentThread().getContextClassLoader();

获取系统的ClassLoader

ClassLoader.getSystemClassLoader();

获取调用者的ClassLoader

DriverManger.getCallerClassLoader();

2.2 用户自定义类加载器

2.2.1 为什么需要自定义类加载器

隔离类加载器
修改类加载方式
扩展加载源
防止源码泄漏

2.2.2 自定义类加载器的实现步骤

继承抽象类java.lang.ClassLoader, 建议把自定义的类加载逻辑放在findClass()方法中。
如果没有特别复杂的需求，可以直接继承URLClassLoader，这样可以避免自己去写findClass方法及其获取字节码流的方式，使自定义类加载器编写更加简洁。

2.3 双亲委派机制

在这里插入图片描述
助记：“往上捅”

用一个案例证明双亲委派机制保证了Java代码的安全性。

package java.lang;

public class String {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}


错误: 在类 java.lang.String 中找不到 main 方法, 请将 main 方法定义为:
   public static void main(String[] args)
否则 JavaFX 应用程序类必须扩展javafx.application.Application

双亲委派机制的好处：

避免类的重复加载
保护程序安全，防止核心api被随意篡改。

2.3 类的加载过程

加载（Loading）-> 【验证（Verification）-> 准备（preparation）-> 解析（Resolution）】-> 初始化（Initilization）
--------------------------【这个就是链接过程】

【加载】

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

.class文件的来源：

本地系统中
网络获取，典型场景：Web Applet。
从zip包中读取，是从jar、war中读取的基础。
运行时计算生成，使用最多的是动态代理技术。
由其他文件生成，典型场景：jsp应用
从专有的数据库中提取.class文件，比较少见
从加密文件中获取，典型的防止Class文件被反编译的保护措施。

【验证】

目的在于确保class文件中包含的信息符合当前虚拟机的要求，保证被加载的类的正确性，不会危害虚拟机自身的安全。
主要包括四种验证：文件格式验证，元数据验证，字节码验证，符号引用验证。

【准备】

为类变量分配内存并且设置类变量的默认初始值，即零值
如果是被final修饰的static变量，就已经是一个常量了，常量在编译阶段已经分配值了，准备阶段会显示初始化。
这里不会为实例变量分配初始化，类变量会分配在方法区中，而实例变量会随着对象一起分配到Java堆中。

【解析】

将常量池内的符号应用转换为直接引用的过程。
事实上，解析操作往往会伴随着JVM在执行完初始化之后再执行。

【初始化】
4. 初始化阶段就是执行类构造器方法 <clinit>()的过程. <clinit>()不同于类的构造器（关联：构造器是虚拟机视角下的<init>()）
5. <clinit>()不需要定义，是由javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并而来。类构造器方法中的指令按照语句在源文件中出现的顺序执行。
6. 若一个类具有父类，JVM会保证子类的<clinit>()执行前，父类的<clinit>()方法已经执行完毕。
7. 虚拟机必须保证一个类的<clinit>()方法在多线程环境下被同步加锁。
8.

public class ClassInitTest {
	static {
		number = 20;
		// 报错：非法的前向引用
		// System.out.println(number);
	}

	// prepare : number = 0;
	// initial : 20 ---> 10
	private static int number = 10; 

	public static void main(String[] args) {
		System.out.println(ClassInitTest.number); // 10
	}
}

2.4 其他

JVM中表示两个class对象是否为同一个类的两个必要条件：

类的完整类名必须一致，包括包名
加载这个类的ClassLoader（指ClassLoader实例对象）必须相同

JVM必须知道一个类型是由启动类加载器加载的还是由用户类加载器加载的。如果一个类型是由用户类加载器加载的，那么JVM会将这个类加载器的一个引用作为类型信息的一部分保存在方法区中。 当解析一个类型到另一个类型的引用的时候，JVM需要保证这两个类型的类加载器是相同的。

Java程序对类的使用分为：主动使用和被动使用。
主动使用情况：
1 创建类的实例
2 访问某个类或者接口的静态变量，或者对该静态变量赋值
3 调用类的静态方法
4 反射（例如Class.forName(“xxxx”)）
5 初始化一个类的子类
6 Java虚拟机启动时被标明为启动类的类
7 JDK7开始提供的动态语言支持：java.lang.invoke.MethodHandle实例的解析结果REF_getStatci、REF-putStatic和REF-invokeStatic句柄对应的类没有初始化，那么就需要初始化
除了主动使用的情况，都是被动使用，被动使用的时候不会导致类的初始化。

3 运行时区域

3.1 本地方法栈

在这里插入图片描述

3.2 程序计数器

在这里插入图片描述
PC Register是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError的区域。

为什么要有PC寄存器？
因为CPU会在不同的线程之间来回切换，切换回来之后，需要知道接着从哪里开始执行。
JVM字节码解释器需要通过改变PC寄存器中的值来明确下一条应该执行什么样的字节码指令。

PC寄存器为什么要设置成为线程私有？
为了能准确记录各个线程正在执行的字节码地址，最好的解决办法就是为每一个线程都分配一个PC寄存器。

3.3 方法区

在这里插入图片描述
独立于堆的一块内存空间。

方法区的大小决定了系统可以保存多少个类，如果系统定义了太多类，方法区溢出，虚拟机同样会抛出OutOfMemoryError。例如加载了大量的第三方的jar包；Tomcat部署的工程过多。大量的生成反射类。

3.3.1 Hotspot中方法区的演进

jdk7以前是永久代，使用的JVM中的内存
JDK8之后，使用元空间。元空间不在虚拟机设置的内存中，而是使用本地内存。

3.3.2 设置方法区内存大小

【java 7】
https://www.oracle.com/java/technologies/javase/vmoptions-jsp.html
https://docs.oracle.com/cd/E74363_01/ohi_vbp_-_installation_guide–20160224-094432-html-chunked/s66.html
https://docs.oracle.com/javase/7/docs/technotes/tools/windows/java.html

-XX:PermSize 设置永久代初始分配空间. 默认值是20.75M. (宋红康)

Option and default value	Description
-XX:MaxPermSize=64m	Size of the Permanent Generation. [5.0 and newer: 64 bit VMs are scaled 30% larger; 1.4 amd64: 96m; 1.3.1 -client: 32m.]。 64位机器默认是82M（宋红康）
【java 8】
https://docs.oracle.com/javase/8/docs/technotes/tools/windows/java.html
https://docs.oracle.com/javase/8/docs/technotes/tools/unix/java.html

XX:MetaspaceSize=size
Sets the size of the allocated class metadata space that will trigger a garbage collection the first time it is exceeded. This threshold for a garbage collection is increased or decreased depending on the amount of metadata used. The default size depends on the platform.
windows下默认值是21M

-XX:MaxMetaspaceSize=size
默认不设限。 -1。设置案例 -XX:MaxMetaspaceSize=256m

3.4 栈

栈管运行，堆管存储。

线程私有。生命周期和线程一致。

8种基本类型的变量 + 对象的引用变量 + 实例方法都是在函数的栈内存中分配。

一个栈帧就对应一个Java方法。

栈是一种快速有效的存储方式，访问速度仅次于程序计数器。栈不存在GC也不存在OOM问题。
在这里插入图片描述

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

使用-Xss设置线程的最大栈空间。
在这里插入图片描述
不同线程中所包含的栈帧不允许存在相互引用，即不可能在一个栈帧之中应用另外一个线程的栈帧。
如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着，虚拟机会丢弃当前栈帧，使得前一个栈帧成为当前栈帧。
Java函数返回方式有两种：一种是正常的函数返回，例如使用了return指令；另外一种是抛出异常（这里是真正的抛出异常。如果异常被捕获处理，那就是正常函数返回。）。无论是哪种方式，都会导致栈帧被弹出。

【栈帧的内部结构】
1 局部变量表，Local Variables
局部变量表也被称为局部变量数组或者本地变量表。

定义为一个数字数组，主要用于存储方法参数和定义在方法体内的局部变量（包括基本数据类型，引用类型和returnAddress类型等）。

局部变量表为线程私有，不存在数据安全问题。

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

对一个函数而言，它的参数和局部变量越多，使得局变量表膨胀，它的栈帧就越大。

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

局部变量表最基本的存储单元是Slot（变量槽）。在局部变量表里，32位以内的类型只占用一个slot（包括returnAddress类型），64位类型（long和double）需要占用两个slot。byte、short、char在存储之前会被转换为int；boolean类型也会被转换为int，0表示false，非0表示true。

如果需要访问局部变量表中一个64bit的局部变量（long或者double）值时，只需要使用前一个索引（64位的占两个slot）即可。

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

Slot是可以重复利用的.

public void test4() {
	int a = 0;
	{
		int b = 0;
		b = a + 1;
	}
	// 局部变量表的长度就是3
	// 变量c使用之前已经销毁的变量b的slot
	int c = a + 1;
}

index  Name
2     b 
0     this
1     a
2     c

【静态变量和局部变量对比】
变量的分类
按照数据类型分：① 基本数据类型 ② 引用数据类型
按照在类中声明的位置分： ① 成员变量：在使用前都经历过默认的初始化过程
<1> 类变量：linking的prepare阶段，给类变量赋默认初始值；initial阶段：执行静态代码块中的语句，赋值。
<2> 实例变量：随着对象的创建，会在堆空间中分配实例变量空间，并进行默认赋值。
② 局部变量：在使用前，必须要进行显式的赋值。否则编译不通过。

public void test5Temp() {
	int num;
	// 直接编译报错：Variable 'num' might not have been initialized.
	System.out.println(num);
}

在栈帧中，与性能调优关系最密切的部分就是局部变量表。在方法执行时，虚拟机使用局部变量表完成方法的传递。
局部变量表中的变量是重要的垃圾回收的根节点，只要被局部变量表中直接或者间接引用的对象都不会被回收。

2 操作数栈， Operand stack，或者称为表达式栈

操作数栈，在方法执行过程中，根据字节码指令，向栈中写入数据或者从栈中提取数据。
例如

[8]                                                                        [23]
[15]           -----------add 操作执行之后--------->                         [其他元素]
[其他元素]

如果被调用的方法有返回值，其返回值会被压入当前栈帧的操作数栈中，并更新pc寄存器中下一条需要执行的指令的偏移地址。
操作数栈中元素的数据类型必须与字节码指令的序列严格匹配。这由编译器在编译期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段会再次验证。
Java虚拟机的解释器是基于栈的执行引擎，这里的栈就是操作数栈。

操作数栈主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。操作数栈就是执行引擎的一个工作区，当一个方法开始执行的时候，会创建新的栈帧，操作数栈也是空的。操作数栈的深度在编译期间就一定确定，保存在Code属性的max_stack中。32位长度的类型占用一个栈深度，64位的占用两个。操作数栈并不能通过数组索引方式访问，只能通过入栈和出栈操作来完成数据访问。

【栈顶缓存技术】
基于栈式架构的虚拟机使用的零地址指令更加紧凑，但是完成一项操作的时候必然要使用更多的入栈和出栈指令，这时就意味着将需要更多的指令分派次数（instruction dispatch）和内存读写次数。

由于操作数是存储在内存中的，因此频繁的内存读写必然会影响执行速度。为了解决此问题，HotSpot JVM设计者们提出了栈顶缓存（ToS， Top-of-Stack Cashing）技术，将栈顶元素全部缓存在物理CPU的寄存器中，为此降低了对内存的读写次数，提升执行引擎的执行效率。

3 动态链接，Dynamic linking，或者称为指向运行时常量池的方法引用
每一个栈帧内部都包含一个指向运行时常量池中该帧所属方法的引用。包含这个应用的目的就是为了支持当前方法能够实现动态链接。比如：invokedynamic指令

在Java源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用（Symbolic Reference）保存在class文件的常量池中。例如：描述一个方法调用了另外的其他方法时，就是通过常量池中指向方法的符号引用来表示的，那么动态链接的作用就是将这些符号引用转换为调用方法的直接引用。

为什么需要常量池？
常量池的作用就是提供一些符合和常量，便于指令识别。

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

绑定：绑定是一个字段、方法或者类在符号引用被替换为直接引用的过程，这个过程仅仅发生一次。
早期绑定：静态链接，目标方法在编译期可知，并且运行期间保持不变，可以直接静态连接。
晚期绑定：动态链接。

C语言这种面向过程的只有早期绑定。面向对象的语言，具有多态性，具备早期绑定和晚期绑定两种绑定方式。

非虚方法：编译期就确定了调用版本，并且运行时不可变。此种就称为非虚方法。
非非虚方法就是虚方法。

普通调用指令
invokestatic：调用静态方法，解析阶段确定唯一方法版本。
invokespecial：调用方法、私有及父类方法，解析阶段确定唯一方法版本。
invokevirtual：调用所有的虚方法，也会调用final修饰的方法，但是final修饰的方法不是虚方法
invokeinterface：调用接口方法。
动态调用指令
invokedynamic：动态解析出需要调用的方法，然后执行。

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

静态类型语言：对类型的检查在编译期。判断变量自身的类型信息。
动态类型语言：对类型的检查在运行期。判断变量值的类型信息，变量没有类型信息。

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

java.lang.IllegalAccessError介绍：程序试图访问或修改一个属性，或者程序试图调用一个方法，但是程序没有对这个属性或者方法的访问权限。一般这种情况就会引起编译器异常。如果这个错误发生在运行时，就说明一个类发生了不兼容的改变。

为了提高性能，JVM在类的方法区建立虚方法表（virtual method table）。使用索引表来代替查找。每个类中都有虚方法表，表中存放各个方法的实际入口。虚方法表会在类加载过程中的链接阶段（Resolving阶段）被创建并初始化，类的变量初始值准备完成之后，JVM会把该类的方法表也初始化完毕。

4 方法返回地址，Return Address，或者称为方法正常异常退出的定义
存放调用该方法的PC寄存器的值

正常退出保存的是PC寄存器的值，异常退出就不保存了。异常退出的返回地址要根据异常表来确定，栈帧中不会保存这部分信息。

ireturn：返回值是boolean，byte，char，short或者int
lreturn：long
freturn： float
dreturn： double
areturn：引用类型
return：没有返回值的，void方法，构造方法，静态代码块等。

5 附加信息
例如，对程序调试提供支持的信息。

3.4.1 几个面试题

【栈溢出】
StackOverFlowError

在这里插入图片描述

3.5 堆

Java虚拟机规范规定，堆可以处于物理上不连续的内存空间中，但是在逻辑上应该是连续的。

堆空间中可以专门划分线程私有缓冲区（Thread Local Allocation Buffer，TLAB）。

在这里插入图片描述
java 8 以及以后逻辑上分为三部分：新生代+老年代+元空间（方法区）。

-Xms ：堆（年轻代+年老带）的起始大小，ms是memory start
-Xmx：堆的最大大小
默认情况下，初始堆大小是物理内存 / 64；最大内存是物理内存 / 4;

查看设置的参数：
方式一：jps / jstat -gc 进程id
方式二：-XX:+PrintGcDetails

Eden满了就会触发YGC（又被称为MinorGC），会回收Eden区和Survivor区中的对象。

幸存者区s0, s1区的运行规则：复制之后有交换，空的就是to区。
在这里插入图片描述

垃圾回收：频繁在新生区收集，很少在老年代收集，几乎不再永久代/元空间收集。

3.5.1 Minor GC、Major GC和Full GC

GC按照回收区域分为部分收集（Partical GC）和整体收集（Full GC）。
部分收集分为：（1）新生代收集：Minor GC / Young GC, 只是新生代的垃圾收集。触发条件：Eden区满的时候。Minor GC会引发STW，暂停其他用户的线程，等垃圾回收结束，用户线程才会恢复运行。（2）老年代收集：Major GC / Old GC, 只是老年代的垃圾收集。目前，只有CMS GC会有单独收集老年代的行为。注意很多时候Major GC和Full GC混淆使用，需要具体分辨是老年代回收还是整体回收。触发条件：老年代空间不足的时候，会先尝试触发minor gc。如果minor gc之后空间还是不足的，则会触发Major gc。（3）混合收集：Mixed GC，收集整个新生代以及部分老年代的垃圾收集。目前，只有G1 GC会有这种行为。

整堆收集：Full GC，收集整个Java堆和方法区。
Full GC执行的情况有：（1）调用System.gc()时，系统建议执行Full GC,但是不是必然执行。（2）老年代空间不足。（3）方法区空间不足。（4）通过Minor GC后进入老年代的平均大小大于老年代的可用内存。（5）向to区复制时，对象大小大于to区可用内存，则把该对象转存到老年代，且老年代的可用内存小于该对象大小。

3.5.2 使用分代思想的原因

不分代也可以，分代的唯一理由就是GC性能优化。

3.5.3 内存分配策略

优先分配到Eden
大对象直接分配到老年代。
程序中应该尽量避免出现过多的大对象。
长期存活的对象分配到老年代。
动态对象年龄判断
如果Survivor区中相同年龄的所有对象的大小总和大于Survivor空间的一半，年龄大于或者等于改年龄的对象可以直接进入老年代，无需等到MaxTenuringTreshold中要求的年龄。
空间分配担保
-XX：HandlePromotionFailure

3.5.4 TLAB

对Eden区进行划分，为每一个线程分配一个私有的缓存区域。
JVM将TLAB作为内存分配的首选。
默认情况下，TLAB空间非常小，仅有Eden空间的1% 。

3.5.5 堆是不是分配对象存储的唯一选择

【栈上分配】

如果经过逃逸分析后发现，一个对象并没有逃逸出方法的话那么就可以被优化成栈上分配。

【同步省略】

逃逸分析会进行锁消除优化。

public void f() {
	Object hollis = new Object();
	synchronized (hollis) {
		System.out.println(hollis);
	}
}

=====优化后=======
public void f() {
	Object hollis = new Object();
	System.out.println(hollis);
}