JVM从零开始学习

运行时数据区及线程

运行时数据区

Java虚拟机定义了若干种程序运行时期间会使用到的运行时数据区，其中有一些会随着虚拟机启动而创建，随着虚拟机退出而销毁。另外一些则是与线程一一对应，这些与线程对应的数据区域会随着线程的开始和结束而创建和销毁。

灰色的为单独线程私有的，红色的为多个线程共享的。即

每个线程：独立包括程序计数器、栈、本地栈。
线程间共享：堆、堆外内存（永久代或元空间、代码缓存）。

线程

线程是一个程序里的运行单元。JVM允许一个应用有多个线程并行的执行。
在HotSpot JVM里，每个线程都与操作系统的本地线程直接映射。

当一个Java线程准备好执行以后，此时一个操作系统的本地线程也同时创建。Java线程执行失败后，本地线程也会回收。
操作系统负责所有线程的安排调度到任何一个可用的CPU上。一旦本地线程初始号成功，它就会调用Java线程中的run（）方法。
如果你使用jconsole或者任何一个调试工具，都能看到在后台有许多线程在运行。这些后台线程不包括调用public static void main(String[])

守护线程、普通线程

这些主要的后台系统线程在HotSpot JVM里主要是以下几点：

虚拟机线程：这种线程的操作是需要JVM达到安全点才会出现。这些操作必须在不同线程中方式的原因是他们都需要JVM达到安全点，这样堆才不会变化。这种线程的执行类型包括“stop-the-world”的垃圾收集，线程栈收集，线程挂起以及偏向锁撤销。
周期任务线程：这种线程是时间周期事件的体现（比如中断），他们一般用户周期性操作的调度执行。
GC线程：这种线程对于在JVM里的不同种类的垃圾收集行为提供支持。
编译线程：这种线程在运行时将字节码编译成到本地代码
信号调度线程：这种线程接受信号并发送到JVM，在它内通过调用适当方法进行处理。

PC Register程序计数器

JVM中的程序计数器，Register的命名源于CPU的寄存器，寄存器存储指令相关的线程信息。CPU只有把数据装载到寄存器中才能够运行。
这里，并非是广义上所指的物理寄存器，或许将其翻译为PC计数器会更加贴切（也称程序钩子），并且不容易引起不必要的误会。JVM中的PC寄存器是对物理PC寄存器的一种抽象模拟。

作用：PC寄存器用来存储指向下一条指令的地址，也即将要执行的指令代码。由执行引擎读取下一条指令。

它是一块很小的内存空间，几乎可以忽略不计。也是运行速度最快的存储区域。
在JVM规范中，每个线程都有它自己的程序计数器，是线程私有的，生命周期与线程的生命周期保持一致。
任何时间一个线程都只有一个方法在执行，也就是所谓的当前方法。程序计数器会存储当前线程正在执行的Java方法的JVM指令地址；或者，如果是在执行native方法，则是未指定值（underfined）。
它是程序控制流的指示器，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。
字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令。
它是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。

转换成流程图

虚拟机栈

内存中的栈和堆

栈是运行时的单位，堆是存储的单位。
即：栈解决程序的运行问题，即程序如何执行，或者说如何处理数据。堆解决的是数据存储的问题，即数据怎么放、放在哪儿。

虚拟机栈的基本内容

Java虚拟机栈是什么？

Java虚拟机，早期也叫Java栈。每个线程在创建时都会创建一个虚拟机栈，其内部保存一个个的栈桢，对应着一次次的Java方法调用。

生命周期

生命周期和线程一致。

作用

主管Java程序的运行，它保存方法的局部变量（8种基本类型、对象的引用地址）、部分结果，并参与方法的调用和返回。

局部变量、成员变量

基本数据变量、引用类型变量（类、数组、接口）

栈的优点

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

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

每个方法执行，伴随着进栈（入栈、压栈）

执行结束后的出栈工作

对于栈来说不存在垃圾回收的问题

栈中可能出现的异常

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

如果采用固定大小的Java虚拟机栈，那每一个线程的Java虚拟机栈容量可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过Java虚拟机栈允许的最大容量，Java虚拟机将会抛出一个StackOverflowError异常。

如果Java虚拟机栈可以动态扩展，并且尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈，那Java虚拟机将会抛出一个OutOfMemoryError异常。

栈的存储单位

栈中存储什么？

每个线程都有自己的栈，栈中的数据都是以栈桢格式存在
在这个线程上正在执行的每个方法都各自对应一个栈桢（Stack Frame）
栈桢是一个内存区块，是一个数据集，维系着方法执行过程中的各种数据信息。

栈运行原理

JVM直接对Java栈的操作只有两个，就是对栈桢的压栈和出栈，遵循“先进后出”、“后进先出”原则。
在一条活动线程中，一个时间点上，只会有一个活动的栈桢。即只有当前正在执行的方法的栈桢（栈顶栈桢）是有效的，这个栈桢被称为当前栈桢，与当前栈桢相对应的方法就是当前方法，定义这个方法的类就是当前类。
执行引擎运行的所有字节码指令只针对当前栈桢进行操作。
如果在这个该方法中调用了其他方法，对应的新的栈桢会被创建出来，放在栈的顶端，称为当前栈桢。
不同线程中所包含的栈桢是不允许存在相互引用的，即不可能在在一个栈桢之中引用另一个线程的栈桢。
如果当前方法调用了其他方法，方法返回之际，当前栈桢会传回此方法的执行结果给前一个栈桢，接着虚拟机会丢弃当前栈桢，使前一个栈桢重新成为当前栈桢。
Java方法有两种返回函数的方式，一种是正常的函数返回，使用return指令；另一种是抛出异常。不管使用哪种方式，都会导致栈桢被弹出。

栈桢的内部结构

每个栈桢中都存储着：

局部变量表
操作数栈（或表达式栈）
动态链接（或指向运行时常量池的方法引用）
方法返回地址（方法正常退出或者异常退出的定义）
一些附加信息

局部变量表

局部变量表被称为局部变量数组或本地变量表
定义为一个数字数组，主要用于存储方法参数和定义在方法体内的局部变量，这些数据类型包括各类基本数据类型、对象引用，以及returnAddress类型。
由于局部变量表是建立在线程的栈上，是线程的私有数据，因此不存在数据安全问题。
局部变量表所需的容量大小在编译期确定下来的，并保存在方法的Code属性的maximum lock variables数据项中。在方法运行期间是不会改变局部变量表的大小的。
方法嵌套调用的次数由栈的大小决定。一般来说，栈越大，方法嵌套调用次数越多。对于一个函数而言，它的参数和局部变量越多，使得局部变量表膨胀，它的栈桢就越大，以满足方法调用所需传递的信息增大的需求。进而函数调用就会占用更多的栈空间，导致其嵌套调用次数就会越少。
局部变量表中的变量只在当前方法调用中有效。在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。当方法调用结束后，随着方法栈桢的销毁，局部变量表也会随之销毁。

字节码中方法内部结构的剖析

-w1563

-w1348

-w1402

-w1673

关于Slot的理解

参数值的存放总是在局部变量数组的index0开始，到数组长度-1的索引结束。
局部变量表，最基本的存储单元是Slot（变量槽）
局部变量表存放编译器可知的各种基本数据类型（8种），引用类型（reference），returnAddress类型的变量。
在局部变量表，32位以内的类型只占用一个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处，其余的参数按照参数表顺序继续排列。

Slot的重复利用

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

public class SlotTest{
    public void localVar(){
      {
        int a = 0;
      }
      //此时变量b就会复用a的槽位。
      int b = 0;
    }
}

静态变量与局部变量的对比

变量的分类：

按照数据类型分：（1）基本数据类型；（2）引用数据类型；

按照在类中声明的位置分：
（1）成员变量：在使用前都经历过默认初始化赋值
类变量：连接的准备阶段：给类变量默认赋值 -> 初始化阶段: 给类变量显式赋值即静态代码块赋值；
实例变量：随着对象的创建，会在堆空间中分配实例变量空间，并进行默认赋值；
（2）局部变量：在使用前，必须要进行显式赋值的，否则编译不通过；

参数表分配完毕之后，再根据方法体内定义的变量的顺序和作用域分配。
我们知道类变量表有两次初始化的机会，第一次是在“准备阶段”，执行系统初始化，对类变量设置零值，另一次则是在“初始化”阶段，赋予程序员在代码中定义的初始值。
和类变量初始化不同的是，局部变量表不存在系统初始化的过程，这意味着一旦定义了局部变量则必须认为的初始化，否则无法使用。
在栈桢中，与性能调优关系最为密切的部分就是前面提到的局部变量表。在方法执行时，虚拟机使用局部变量表完成方法的传递。
局部变量表中的变量也是重要的垃圾回收根节点，只要被局部变量表中直接或间接引用的对象都不会被回收。

操作数栈

每一个独立的栈桢中除了包含局部变量表以外，还包含一个后进先出的操作数栈，也可以称之为表达式栈。
操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈/出栈
- 某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出栈。使用他们后再把结果压入栈。
- 比如：执行复制、交换、求和等操作。
如果被调用的方法带有返回值的话，其返回值将会被压入当前栈桢的操作数栈中，并更新PC寄存器中下一条需要执行的字节码指令。
操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，这由编译器在编译器期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段再次验证。
另外，我们说Java虚拟机的解释引擎是基于栈的执行引擎，其中的栈指的就是操作数栈。
操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时存储空间。
操作数栈就是JVM执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈桢也会随之被创建出来，这个方法的操作数栈是空的。
每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译器就定义好了，保存在方法的Code属性中，为max_stack的值。
栈中的任何一个元素都是可以任意的Java数据类型。
- 32bit的类型占用一个栈单位深度。
- 64bit的类型占用两个栈单位深度。
操作数栈并非采用访问索引的方式来进行数据访问的，而是只能通过标准的入栈和出栈操作来完成一次数据访问。

动态链接（指向运行时常量池的方法引用）

每一个栈桢内部都包含一个指向运行时常量池中该栈桢所属方法的引用。包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接。比如： invokedynamic指令
在Java源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用保存在class文件的常量池里。比如：描述一个方法调用了另外的其他方法时，就是通过常量池中指向方法的符号引用来表示的，那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用。

那么什么是动态链接，具体看下面的例子

public class DynamicTest {
    int num = 0;
    
    private  void methodA(){
        System.out.println("methodA");
    }
    
    private int methodB(){
        methodA();
        num++;
        return num;
    }
}

字节码指令 javap 反编译后

-w786

常量池在运行时会放入方法区，所以叫作运行时常量池。
常量池的作用是：提供一些符号和常量，便于指令的识别。

方法的调用

在JVM中，将符号引用转换为调用方法的直接引用于方法的绑定机制相关。

静态链接：当一个字节码文件被装载进JVM内部时，如果被调用的目标方法在编译期可知，且运行期保持不变时。这种情况下将调用方法的符号引用转换为直接引用的过程称之为静态链接。
动态链接：如果被调用的方法在编译期无法被确定下来，也就是说，只能够在程序运行期将调用方法的符号引用转换为直接引用，由于这种引用转换过程具备动态性，因此也就被称之为动态链接。
对应的方法的绑定机制为:早期绑定和晚期绑定。绑定是一个字段、方法或者类在符号引用被替换为直接引用的过程，这仅仅发生一次。
早期绑定：就是指被调用的目标方法如果在编译期可知，且运行期保持不变时，即可将这个方法与所属的类型进行绑定，这样一来，由于明确了被调用的目标方法究竟是哪一个，因此也就可以使用静态链接的方式将符号引用转换为直接引用。
晚期绑定：如果被调用的方法在编译期无法被确定下来，只能够在程序运行期根据实际的类型绑定相关的方法，这种绑定方式也就被称之为晚期绑定。

非虚方法（编译期确定具体调用方法）
静态方法、私有方法、final方法、实例构造器、父类方法都是非虚方法。
其他方法都是称为虚方法。

虚拟机提供了一下几条方法调用指令：

普通调用指令:
1.invokestatic：调用静态方法，解析阶段确定唯一方法版本
2.invokespecial：调用方法、私有及父类方法，解析阶段确定唯一方法版本
3.invokevirtual：调用所有虚方法（final方法除外）
4.invokeinterface：调用接口方法

动态调用指令
5.invokedynamic：动态解析出需要调用的方法，然后执行
前四条指令固化在虚拟机内部，方法的调用执行不可人为干预，而invokedynamic指令则支持由用户确定方法版本。其中invokestatic指令和invokespecial指令调用的方法称为非虚方法，其余的（final修饰的除外）称为虚方法。

方法调用：方法重写的本质

Java语言中方法重写的本质

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

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

方法调用：虚方法表

在面向对象的编程中，会很频繁的使用动态分派，如果在每次动态分派的过程中都要重新再类的方法元数据中搜索合适的目标的话就可能影响到执行效率。因此，为了提高性能，JVM采用在类的方法区建立一个虚方法表（非虚方法不会出现在这个表中）来实现。使用索引表来代替查找。
每个类中都有一个虚方法表，表中存放着各个方法的实际入口。
那么虚方法表什么时候被创建？
虚方法表会在类加载的链接阶段被创建并开始初始化，类的变量初始值准备完成之后，JVM会把该类的方发表也初始化完毕。

方法返回地址

存放调用该方法的PC寄存器的值
一个方法的结束，有两种方式：
- 正常执行完成
- 出现未处理的异常，非正常退出
无论通过哪种方式退出，在方法退出后都返回到该方法被调用的位置。方法正常退出时，调用者的PC计数器的值作为返回地址，即调用该方法的指令的下一个指令的地址。而通过异常退出的，返回地址是要通过异常表来确定，栈桢中一般不会保存这部分信息。
当一个方法喀什执行后，只有两种方式可以退出这个方法:
1.执行引擎遇到任意一个方法返回的字节码指令，会有返回值传递给上层的方法调用者，简称正常完成出口；
一个方法的正常调用完成之后究竟需要使用哪一个返回指令还需要根据方法返回值的实际数据类型而定。
在字节码指令汇总，返回指令包含ireturn（当返回值是boolean、byte、char、short和int类型时使用）、lreturn、freturn、dreturn以及areturn，另外还有一个return指令供声明为void的方法、实例初始化方法、类和接口的初始化方法使用。
2.在方法执行的过程中遇到了异常，并且这个异常没有在方法内进行处理，也就是只要在本方法的异常表中没有搜索到匹配的异常处理器，就会导致方法退出。简称异常完成出口。
方法执行过程中抛出异常时的异常处理，存储在一个异常处理表，方便发生异常的时候找到处理异常的代码。

字节码异常表

Exception			tbale
from	to	target	type
4	16	19	any
19	21	19	any

上面的数字from或to以及target的数字代表的是字节码地址，type是异常类型。

栈面试的题目

举例栈溢出的情况？（StackOverflowError）
通过设置-Xss设置栈的大小
调整栈大小就能保证不出现溢出吗？
不能
分配的栈内存越大越好吗？
不是
垃圾回收是否会涉及到虚拟机栈？
不会

本地方法接口

什么是本地方法？

简单地讲，一个Native Method就是一个Java调用非Java代码的接口，一个Native Method是这样一个Java方法；该方法的实现由非Java语言实现，比如C。这个特征并非Java所持有，很多其他的编程语言都有这一机制，比如在C++中你可以用extern “C”告诉C++编译器去调试一个C的函数。
在定义一个Native method时，并不提供实现体，因为其实现体是由非Java语言在外面实现的。

为什么要使用Native Method？

Java使用起来非常方便，然而有些层次的任务用Java实现起来不容易，或者我们对程序的效率很在意时，问题就来了。

与Java环境外交互：
有时java应用需要与Java外面的环境交互，这是本地方法存在的主要原因。
与操作系统交互
Sun‘s Java

本地方法栈

Java虚拟机栈用于管理Java方法的调用，而本地方法栈用于管理本地方法的调用。
本地方法栈，也是线程私有的。
允许被实现成固定或者是可动态扩展的内存大小。
- 如果线程请求分配的栈容量超过本地方法栈允许的最大容量，Java虚拟机将会抛出一个StackOverflowError异常
- 如果本地方法栈可以动态扩展，并且尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的本地方法栈，那么Java虚拟机将会抛出一个OutOfMemoryError异常。
本地方法是使用C语言实现的。
它的具体做法是Native Method Stack中登记Native方法，在Execution Engine执行时加载本地方法库。
当某一个线程调用一个本地方法时，它进入了一个全新的并且不再受虚拟机限制的世界。它和虚拟机拥有同样的权限。
- 本地方法可以通过本地方法接口来访问虚拟机内部的运行时数据区。
- 它甚至可以直接使用本地处理器中的寄存器。
- 直接从本地内存的堆中分配任意数量的内存。
并不是所有的JVM都支持本地方法。因为Java虚拟机规范并没有明确要求本地方法栈的使用语言、具体实现方式、数据结构等。如果JVM产品不打算支持Native方法，也可以无需实现本地方法栈。
在HotSpot JVM中，直接将本地方法栈和虚拟机栈合二为一。

堆

堆的核心概述

一个JVM实例只存在一个堆内存，堆也是Java内存管理的核心区域。
Java堆区在JVM启动的时候即被创建，其空间大小也就确定了。是JVM管理的最大一块内存空间。
- 堆内存的大小是可以调节的。
《Java虚拟机规范》规定，堆可以处于物理上不连续的内存空间中，但在逻辑上它应该被视为连续的。
所有的线程共享Java堆，在这里还可以划分线程私有的缓冲区
《Java虚拟机规范》中对Java堆的描述是：所有的对象实例以及数组都应当运行时分配在堆上。
数组和对象可能永远不会存储在栈上，因为栈桢中保存引用，这个引用指向对象或者数组在堆中的位置。
在方法结束后，堆中的对象不会马上被移除，仅仅在垃圾收集的时候才会被移除。
堆，是GC（Garbage Collection，垃圾收集器）执行垃圾回收的重点区域。

内存细分

现代垃圾收集器大部分基于分代收集理论设计，堆空间细分为：

Java 8 及以后堆内存逻辑上分为三部分：新生代、老年代、元空间
- Young Generation Space 新生代 Young/New
  - 又被划分为Eden区和Survivor区
- Tenure Generation Space 老年代 Old/Tenure
- Meta Space 元空间 Meta

堆空间大小设置

Java堆区用于存储Java对象实例，那么堆的带下在JVM启动时就已经设定好了，可以通过选项“-Xmx” 和“-Xms”来进行设置。
- “-Xms”用于表示堆区的初始内存，等价于-XX:InitialHeapSize
- “-Xmx”用于表示堆区的最大内存，等价于-XX:MaxHeapSize
一旦堆区中的内存大小超过“-Xmx”所指定的最大内存时，将会抛出OutOfMemoryError异常。
通常会将-Xms和-Xmx设置相同的值，其目的是为了能够在Java垃圾回收机制清理完堆区后不需要重新分隔计算堆区大小，从而提高性能。
默认情况下，初始内存大小：物理电脑内存大小/64，最大内存大小：物理电脑内存大小/4。

测试程序：

    public static void main(String[] args) {
        long mNum = 1024 * 1024;
        //返回Java虚拟机中的堆的内存总量
        long initialMemory = Runtime.getRuntime().totalMemory() / mNum;
        //返回Java虚拟机试图使用的最大堆内存空间
        long maxMemory = Runtime.getRuntime().maxMemory() / mNum;
        System.out.println("-Xms:" + initialMemory + "M");
        System.out.println("-Xmx:" + maxMemory + "M");

        System.out.println("系统内存大小为：" + initialMemory * 64 / 1024 + "G" );
        System.out.println("系统内存大小为：" + maxMemory * 4 / 1024 + "G" );
    }

假设设置-Xms600M -Xmx600M，我们发现打印结果如下：

发现只有575M，我们可以打开CMD或者终端；

jps 命令查看当前的应用进程号

然后用命令 jstat -gc 【进程号】

可以查看到
S0C 25600
S1C 25600
S0U 0
S1U 0
EC 153600
EU 15360.5
OC 409600

S0C、S1C、EC属于新生代 OC属于老年代

（S0C + S1C + EC + OC）/ 1024 = 600M
但是为什么使用只有575，因为在实际使用中S0C和S1C只有一个使用，所以少了25M

或者在VM参数中增加-XX:+PrintGCDetails

打印信息如下：

年轻代和老年代

存储在JVM中的Java对象可以被划为两类:
- 一类是生命周期较短的瞬时对象，这类对象的创建和消亡都非常迅速
- 另外一类对象的生命周期却非常长，在某些极端的情况下还能够与JVM的生命周期保持一致
Java堆区进一步细分的话，可以划分为年轻代和老年代
其中年轻代又可以划分为Eden空间，Survivor0空间和Survivor1空间（有时也叫from区、to区）
配置新生代和老年代的堆结构
- 默认-XX:NewRatio=2,表示新生代占1，老年代占2，新生代占整个堆的1/3
- 可以修改-XX:NewRatio=4,表示是新生代占1，老年代占4，新生代占整个堆的1/5
可以通过命令 jinfo -flag NewRatio 【进程号】查看进程的堆结构比例
在HotSpot中，Eden空间和另外两个Survivor空间缺省所占的比例是8：1：1
当然开发人员可以通过选项-XX:SurvivorRatio调整这个空间比例。比如-XX:SurvivorRatio=8
几乎所有的Java对象都是在Eden区被new出来的
绝大部分的Java对象的销毁都在新生代进行了。
可以使用选项”-Xmn“设置新生代最大内存大小
- 这个参数一般使用默认值就可以了。

对象分配过程

为新对象分配内存时一件非常严谨和复杂的任务，JVM的设计者不仅需要考虑内存如何分配、在哪里分配等问题，并且由于内存分配算法与内存回收算法密切相关，所以还需要考虑GC执行完内存回收后是否会在内存空间中产生内存碎片。

new的对象先放Eden区，此区有大小限制。
当Eden区的空间填满时，程序又需要创建对象，JVM的垃圾回收器将对Eden区进行垃圾回收（Minor GC），将Eden区中不再被其他对象所引用的对象进行销毁。再加载新的对象放到Eden区。
然后将Eden区中的剩余对象移动到Survivor0区
如果再次触发垃圾回收，此时上次幸存下来的放到Survivor0区的，如果没有回收，就会放到Survivor1区。
如果再次经历垃圾回收，此时会重新放回Survivor0区，接着再去Survivor1区。
什么时候去养老区呢？默认15次。可以设置参数-XX:MaxTenuringThreshold<N>进行设置。

总结：

针对Survivor0，Survivor1区总结：复制之后又交换，谁空谁是To。

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

Minor GC、Major GC与Full GC

JVM在进行GC时，并非每次都对上面三个内存区域（新生代、老年代；方法区）一起回收的，大部分时候回收的都是指新生代。
针对HotSpot VM的实现，它里面的GC按照回收区域分为两大种类型：一种是部分收集（Partial GC），一种是整堆收集（Full GC）

部分收集：不是完整收集整个Java堆的垃圾收集，其中又分为：
- 新生代收集（Minor GC / Young GC）：只是新生代（Eden/S0、S1）的垃圾收集。
- 老年代收集（Major GC / Old GC）：只是老年代的垃圾收集。
  - 目前，只有CMS GC会有单独收集老年代的行为。
  - 注意，很多时候Major GC 会和Full GC混淆使用，需要具体分辨是老年代回收还是整堆回收。
- 混合收集（Mixed GC）：收集整个新生代以及部分老年代的垃圾收集。
  - 目前只有G1 GC会有这种行为。
整堆收集（Full GC）：收集整个Java堆的方法区的垃圾收集。

最简单的分代式GC策略的触发条件

年轻代GC（Minor GC）触发机制：
- 当年轻代空间不足时，就会触发Minor GC，这里的年轻代满指的是Eden区满，Survivor满不会引发GC。（每次Minor GC会清理年轻代的内存。）
- 因为Java对象大多都具备朝生夕灭的特性，所以Minor GC非常频繁，一般回收速度也比较快。
- Minor GC会引发STW，暂停其他用户线程，等垃圾回收结束，用户线程才恢复运行。
老年代GC（Major GC/FUll GC）触发机制：
- 指发生在老年代的GC，对象从老年代消失时，我们说：”Major GC“或”Full GC“发生了。
- 出现了Major GC，经常会伴随至少一次的Minor GC（但非绝对的，在Parallel Scavenge收集器的手机策略里就直接进行Major GC的策略选择过程）。
  - 也就是在老年代空间不足时，会先尝试触发Minor GC。如果之后空间还不足，则触发Major GC
- Major GC的速度一般会比Minor GC慢10倍以上，STW的时间更长。
- 如果Major GC后，内存还不足，就报OOM了。
Full GC触发机制：
触发Full GC 执行情况有如下五种：
（1）调用System.gc()时,系统建议执行Full GC，但是不必然执行。
（2）老年代空间不足。
（3）方法区空间不足。
（4）通过Minor GC后进入老年代的平均代销大于老年代的可用内存。
（5）由Eden区、Survivor Space0（From Space）区向Survivor Space1（To Space）区复制时，对象大小大于To Space可用内存，则把该对象转存到老年代，且老年代的可用内存小于该对象大小。
说明：Full GC是开发或调优中尽量避免的，这样暂停时间会短一些。

内存分配策略（或对象提升（Promotion）规则）

如果对象在Eden出生并经过第一次MinorGC后仍然存活，并且能被Survivor容纳的话，将被移动到Survivor空间中，并将对象年龄设为1。对象在Survivor区中每熬过一次Minor GC，年龄就增加1岁，当它的年龄增加到一定程度（默认15岁，其实每个JVM、每个GC都有所不同）时，就会被晋升到老年代中。
对象晋升老年代的年龄阈值，可以通过选项-XX:MaxThenuringThreshold来设置。
针对不同年龄段的对象分配原则如下所示：

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

对象分配过程：TLAB

为什么有TLAB（Thread Local Allocation Buffer 线程本地分配缓存区）？

堆区是线程共享区域，任何线程都可以访问到堆区中的共享数据
由于对象实例的创建在JVM中非常频繁，因此在并发环境下从堆区中划分内存空间是线程不安全的。
为避免多个线程操作同一地址，需要使用加锁等机制，进而影响分配速度。

什么是TLAB？

从内存模型而不是垃圾收集的角度，对Eden区域继续进行划分，JVM为每个线程分配了一个私有缓存区域，它包含在Eden空间内。
多线程同时分配内存时，使用TLAB可以避免一系列的非线程安全问题，同时还能够提升内存分配的吞吐量，因此我们将这种内存分配方式称之为快速分配策略。
所有的OpenJDK衍生出来的JVM都提供了TLAB的设计。

TLAB的再说明

尽管不是所有的对象实例都能够在TLAB中成功分配内存，但JVM确实将TLAB作为内存分配的首选。
在程序中，开发人员可以通过选项-XX:UseTLAB设置是否开启TLAB空间。
默认情况下，TLAB空间的内存非常小，仅占有整个Eden空间的1%，当我们可以通过选项-XX:TLABWasteTargetPercent设置TLAB空间所占用Eden空间的百分比大小。
一旦对象在TLAB空间分配内存失败时，JVM就会尝试着通过使用加锁机制确保数据操作的原子性，从而直接Eden空间中分配内存。

对象分配过程：TLAB

堆空间中常用的JVM参数

-XX:+PrintFlagsInitial查看所有参数的默认初始值
-XX:+PrintFlagsFinal查看所有的参数的最终值（可能会存在修改，不再是初始值）
-Xms初始堆空间内存（默认为物理内存的1/64）
-Xmx最大堆空间内存（默认为物理内存的1/4）
-Xmn设置新生代的大小。（初始值及最大值）
-XX:NewRatio配置新生代与老年代的堆结构占比
-XX:SurvivorRaito设置新生代中Eden与S0/S1的空间比例。
- 如果设置此值偏大
  如果伊甸园区比较大那么幸存者0/1区就比较小,可以存放的对象就比较少，再往伊甸园区对象后发生Minor GC时幸存者区很可能回满，则幸存者区的对象就会直接去老年代，这样导致的后果是Minor GC失去意义，因为此时Minor GC无法回收幸存者区，且里面的对象年龄没有达到阈值15就会去老年代。那么可能提高Major GC次数。
- 如果设置此值偏小
  如果伊甸园区比较小，幸存者区比较大。因为YoungGC或者Minor GC是伊甸园区满的时候触发，如果此时伊甸园区比较小，那么触发Minor GC就比较频繁，会影响用户进程，STW时间变长。
-XX：MaxTenuringThreshold设置新生代垃圾的最大年龄
-XX：+PrintGCDetails输出详细的GC处理日志
-XX:+PrintGC和-verbose:gc打印gc简要信息
-XX:HandlePromotionFailure是否设置空间分配担保

在发生Minor GC之前，虚拟机会检查老年代最大可用的连续空间是否大于新生代所有对象的总空间。

如果大于，则此次Minor GC是安全的
如果小于，则虚拟机会查看-XX:HandlePromotionFailure设置值是否允许担保失败。
- 如果HanlePromotionFailure=true，那么会继续检查老年代最大可用连续空间是否大于历次晋升到老年代的对象的平均大小。
  - 如果大于，则尝试一次Minor GC，但这次Minor GC依然是由风险的；
  - 如果小于，则改为进行一次Full GC。
- 如果HandlePromotionFailure=false，则改为进行一次Full GC.

JDK6 Update24之后的规则变为只要老年代的连续空间大于新生代对象总大小或者历次晋升的平均大小就会进行Minor GC，否则将进行Full GC。

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

在《深入理解Java虚拟机》中关于Java堆内存有这样一段描述:
随着JIT编译期的发展与逃逸分析技术逐渐成熟，栈上分配、标量替换优化技术将会导致一些微妙的变化，所有的对象都分配到堆上也渐渐不那么绝对了。
在Java虚拟机中，对象是Java堆中分配内存的，这是一个普遍的常识。但是有一种特殊情况，那就是如果经过逃逸分析后发现，一个对象并没有逃逸出方法的话，那么就可能被优化成栈上分配。这样就无需再堆上分配内存，也无须进行垃圾回收了。这也是最常见的堆外存储技术。
基于OpenJDK深度定制的TaoBaoVM，其中创新的GCIH（GC invisible heap）技术实现off-heap，将生命周期较长的Java对象从heap中移至heap外，并且GC不能管理GCIH内部的Java对象，从此达到降低GC的回收频率和提升GC的回收效率的目的。

逃逸分析概述

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

发生逃逸的几种情况。

public class EscapeAnalysis {
    public EscapeAnalysis obj;


    /*
    * 方法返回EscapeAnalysis对象，发生逃逸
    * */
    public EscapeAnalysis genInstance(){
        return obj == null? new EscapeAnalysis() : obj;
    }

    /*
    * 为成员属性赋值，发生逃逸
    * */
    public void setObj(){
        this.obj = new EscapeAnalysis();
    }

    
    /*
    * 引用成员变量的值，发生逃逸
    * */
    public  void useEscapeAnalysis(){
        EscapeAnalysis escapeAnalysis = genInstance();
    }
}

可以通过-XX:+PrintEscapeAnalysis查看逃逸分析的筛选结果。

逃逸分析：代码优化

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

栈上分配

JIT编译期在编译期间根据逃逸分析的结果，发现如果一个对象并没有逃逸出方法的话，就可能被优化为栈上分配。分配完成后，继续在调用栈内执行，最后线程结束，栈空间被回收，局部变量对象也被回收。这样就无须进行垃圾回收了。
常见的栈上分配的场景
- 逃逸分析汇总，已经说明了。分别是给成员变量赋值、方法返回值、实例引用传递。

同步省略

线程同步的代价是相当高的，同步的后果是降低并发性和性能。
在动态编译同步块的时候，JIT编译期可以借助逃逸分析来判断同步块所使用的锁对象是否只能够被一个线程访问而没有被发布到其他线程。如果没有，那么JIT编译期在编译这个同步块的时候就会取消对着部分代码的同步。这样就能大大提高并发性和性能，这个取消同步的过程就叫同步省略，也叫锁消除。

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

优化为

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

分离对象或标量替换

标量是指无法再分解成更小的数据的数据。Java中原始数据类型就是标量。
相对的，那些还可以分解的数据叫作聚合量，Java中的对象就是聚合量，因为他可以分解成其他聚合量和标量。
在JIT阶段，如果经过逃逸分析，发现一个对象不会被外界访问的话，那么经过JIT优化，就会把这个对象拆解成若干个其中包含的若干个成员变量来代替。这个过程就是标量替换。

方法区

栈、堆、方法区的关系

运行时数据区结构图

从线程共享与否角度来看

运行时数据区结构图

栈、堆、方法区的交互关系

这两幅图中：

reference就是person
Person就是对象类型数据
new Person就是对象实例数据

方法区的理解

《Java虚拟机规范》中明确说明：”尽管所有的方法区在逻辑上是属于堆的一部分，但一些简单的实现可能不会选择去进行垃圾收集或者进行压缩。“ 但对于HotSpotJVM而言，方法区还有一个别名叫作Non-Heap（非堆），目的就是要和堆分开。
所以，方法区看作是一块独立于Java堆的内存空间。

方法区（Method Area）与Java堆一样，是各个线程共享的内存区域。
方法区在JVM启动的时候被创建，并且它的实际的物理内存空间中和Java堆区一样都可以是不连续的。
方法区的大小，跟堆空间一样，可以选择固定大小或者可扩展。
方法区的大小决定了系统可以保存多少个类，如果系统定义了太多类，导致方法区溢出，虚拟机同样会抛出内存溢出错误：java.lang.OutOfMemoryError: PermGen space或者java.lang.OutOfMemoryError:Metaspace
- 加载大量的第三方的jar包：Tomcat部署的工程过多（30-50），大量动态的生成反射类。
关闭JVM就会释放这个区域的内存。

HotSpot中方法区的演进

在jdk7及以前，习惯上把方法区，称为永久代。jdk8开始，使用元空间取代了永久代。
本质上，方法区和永久代并不等价，仅是对HotSpot而言。《Java虚拟机规范》对如何实现方法区，不做统一要求。列如：BEA JRockit/IBM J9中不存在永久代的概念。
- 现在来看，当年使用永久代，不是好的idea。导致Java程序更容易OOM（超过-XX:maxPermSize上限）
而到JDK8放弃了永久代的概念，改用与JRockit、J9一样在本地内存中实现的元空间（Metaspace）来代替。
元空间的本质与永久代类似，都是对JVM规范中方法区的实现，不过元空间与永久代最大的区别在于：元空间不在虚拟机设置的内存中，而是使用本地内存。
永久代、元空间二者不只是名字变了，内部结构也调整了。
根据《Java虚拟机规范》的规定，如果方法区无法满足新的内存分配需求时将抛出OOM异常。

设置方法区大小和OOM

JDK8及以后：

元数据区大小可以使用参数-XX:MetaspaceSize和-XX:MaxMetaspaceSize指定，替代上述原有的两个参数。
默认值依赖于平台。windows下，-XX:MetaspaceSize是21M，-XX:MaxMetaspaceSize的值是-1,即没有限制。
与永久代不通，如果不指定大小，默认情况下，虚拟机会耗尽所有的可用系统内存。如果元数据区发生溢出，虚拟机一样会抛出异常OutOfMemoryError:Metaspace
-XX:MetaspaceSize设置初始的元空间大小。对于一个64位服务器端JVM来说，其默认的-XX:MetaspaceSize值位21MB。这就是初始的高水位线，一旦触及这个水位线，Full GC将会被触发并卸载没有用的类（即这些类对应的类加载器不再存活），然后这个高水位线将被重置。新的高水位线的值取决于GC后释放了多少元空间。如果释放的空间不足，那么在不超过MaxMetaspaceSize时，适当提高该值。如果释放空间过多，则适当降低该值。
如果初始化的高水位线设置过低，上述高水位线调整情况会发生很多次。通过垃圾回收器的日志可以观察到Full GC多次调用。为了避免频繁地GC，建议将-XX:MetaspaceSize设置一个相对较高的值。

如何解决这些OOM？

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

方法区存储什么？

它用于存储已被虚拟机加载的类型信息、常量、静态变量、即时编译期编译后的代码缓存等。

方法区的内部结构

类型信息

对每个加载的类型（类class、接口interface、枚举enum、注解annotation），JVM必须在方法区中存储以下类型信息：
（1）这个类型的完整有效名称（全名=包名.类名）
（2）这个类型的直接父类的完整有效名（对于interface或是java.lang.Object 都没有父类）
（3）这个类型的修饰符（public，abstract，final的某个子集）
（4）这个类型直接接口的有一个有序列表

域信息

JVM必须在方法区中保存类型的所有域的相关信息以及域的声明顺序。
域的相关信息包括：域名称、域类型、域修饰符（public，private，protected，static，final，volatile，transient的某个子集）

方法信息

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

方法名称
方法的返回类型（或 void）
方法参数的数量和类型（按顺序）
方法的修饰符（public，private，protected，static，final，synchronized，native，abstract的一个子集）
方法的字节码（bytecodes）、操作数栈、局部变量表及大小（abstract和native方法除外）
异常表（abstract和native方法除外）
- 每个异常处理的开始位置、结束位置、代码处理在程序计数器中的偏移地址被捕获的异常类的常量池索引。

运行时常量池

运行时常量池是方法区的一部分。
常量池表（Constant Pool Table）是class文件的一部分，用于存放编译期生成的各种字面量与符号引用，这部分内容将在类加载后存放到方法区的运行时常量池中。
运行时常量池，在加载类和接口到虚拟机后，就会创建对应的运行时常量池。
JVM为每个已加载的类型都维护一个常量池。池中的数据项像数组项一样，是通过索引访问的。
运行时常量池中包含多种不同的常量，包括编译期就已经明确的数值字面量，也包括到运行期解析后才能够获得的方法或者字段引用，此时不再是常量池中的符号地址了，这里换为真实地址。
- 运行时常量池，相对于Class文件常量池的另一个重要特征是：具备动态性。
  - String.intern()
运行时常量池类似于传统编程语言中的符号表，但是它包含的数据却比符号表更加丰富一些。
当创建类或者接口的运行时常量池时，如果构造运行时常量池所需的内存空间超过方法区所能提供的最大值，则JVM会抛OutOfMemoryError异常。

运行时常量池 VS 常量池

方法区内部包含了运行时常量池。
字节码文件，内部包含了常量池。
要弄清楚方法区，需要理解清楚ClassFile，因为家在类的信息都在方法区。
要弄清楚方法区的运行时常量池，需要理解清楚ClassFile中的常量池。

常量池、可以看做是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等类型。

方法区的演进细节

1.首先明确：只有HotSpot才有永久代。BEA、JRockit、IBM J9等来说，是不存在永久代的概念的。原则上如何实现方法区属于虚拟机实现细节，不受《Java虚拟机规范》管束，并不要求统一。
2.HotSpot中方法区的变法：

JDK1.6及以前	有永久代（permanent Generation），静态变量存放在永久代上
JDK1.7	有永久代，但已经逐步”去永久代“，字符串常量池、静态变量移除，保存在堆中
JDK1.8及以后	无永久代，类型信息、字段、方法、常量保存在本地内存的元空间，但字符串常量池、静态变量仍在堆

永久代为什么要被元空间替换？

随着Java8的到来，HotSpot VM中再也见不到永久代了。但是这并不意味着类的元数据信息也消失了。这些数据被移动到一个与堆不相连的本地内存区域，这个区域叫做元空间（Mataspace）。
由于类的元数据分配的本地内存中，元空间的最大可分配空间就是系统可用内存空间。
这项改动是很有必要的，原因有：
- 为永久代设置大小是很难确定的。
  在某些场景下，如果动态加载类过多，容易产生perm区的OOM。比如某个实际Web工程中，因为功能点比较多，在运行过程汇总，要不断动态加载很多类，经常出现致命错误。
  Exception in thred 'doubbo client x.x connection' java.lang.OutOfMemoryError:PermGenspace'
  而元空间和永久代之间最大的区别在于：元空间并不在虚拟机中，而是使用本地内存。因此，默认情况下，元空间的大小仅受本地内存限制。
- 对永久代进行调优是很困难的。

StringTable为什么要调整？

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

方法区的垃圾收集

这个区域的回收效果比较难令人满意，尤其是类型的卸载，条件相当苛刻。但是这部分区域的回收有时又确实是必要的。
方法区的垃圾收集主要回收两部分内容：常量池中废弃的常量和不再使用的类型。

方法区内常量池之中主要存放的两个类常量：字面量和符号引用。字面量比较接近Java语言层次的常量概念，如文本字符串、被声明为final的常量值等。而符号引用则属于编译原理方面的概念，包括下面三类常量：
1. 类和接口的权限定名
2. 字段的名称和描述符
3. 方法的名称和描述符
HotSpot虚拟机对常量池的回收策略是很明显的，只要常量池中常量没有被任何地方引用，就可以被回收。
回收废弃常量与回收Java堆中的对象非常相似。
判定一个常量是否“废弃”还是相对简单，而要判定一个类型是否属于“不再被使用的类”的条件就比较苛刻了。需要同时满足下面三个条件：
- 该类所有的实例都已经被回收，也就是Java堆中不存在该类及其任何派生子类的实例。
- 加载该类的类加载器已经被回收，这个条件除非是经过精心设计的可替换类加载器的场景，如OSGI、JSP的重加载等，否则通常是很难达成的。
- 该类对应的java.lang.Class对象没有在任何地方被引用，无法再任何地方通过反射访问该类的方法。
Java虚拟机被允许对满足上述三个条件的无用类进行回收，这里说的仅仅是“被允许”，而并不是和对象一样，没有引用就必然会回收。关于是否对类型进行回收，HotSpot虚拟机提供了-Xnoclassgc参数进行控制，还可以使用-verbose:class以及-XX:+TraceClass-Loading、-XX:+TraceClassUnLoading查看类加载和卸载信息。
在大量使用反射、动态代理、CGLib等字节码框架，动态生成JSP以及OSGI这类频繁自定义类加载器的场景中，通常都需要Java虚拟机具备类型卸载的能力，以保证不会对方法区造成过大的内存压力。

运行时方法区

原文地址：https://www.cnblogs.com/yantt/p/jvm-cong-ling-kai-shi-xue-xi-yi.html

运行时数据区及线程

运行时数据区

线程

PC Register程序计数器

虚拟机栈

内存中的栈和堆

虚拟机栈的基本内容

栈的存储单位

栈中存储什么？

栈运行原理

栈桢的内部结构

局部变量表

字节码中方法内部结构的剖析

关于Slot的理解

Slot的重复利用

静态变量与局部变量的对比

操作数栈

动态链接（指向运行时常量池的方法引用）

方法的调用

方法调用：方法重写的本质

方法调用：虚方法表

方法返回地址

栈面试的题目

本地方法接口

什么是本地方法？

为什么要使用Native Method？

本地方法栈

堆

堆的核心概述

内存细分

堆空间大小设置

年轻代和老年代

对象分配过程

Minor GC、Major GC与Full GC

最简单的分代式GC策略的触发条件

内存分配策略（或对象提升（Promotion）规则）

对象分配过程：TLAB

为什么有TLAB（Thread Local Allocation Buffer 线程本地分配缓存区）？

什么是TLAB？

TLAB的再说明

对象分配过程：TLAB

堆空间中常用的JVM参数

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

逃逸分析概述

逃逸分析：代码优化

栈上分配

同步省略

分离对象或标量替换

方法区

栈、堆、方法区的关系

运行时数据区结构图

栈、堆、方法区的交互关系

方法区的理解

HotSpot中方法区的演进

设置方法区大小和OOM

如何解决这些OOM？

方法区存储什么？

方法区的内部结构

类型信息

域信息

方法信息

运行时常量池

运行时常量池 VS 常量池

方法区的演进细节

永久代为什么要被元空间替换？

StringTable为什么要调整？

方法区的垃圾收集

相关推荐