JVM核心知识点-升职加薪/面试必备技能整理

类加载子系统：加载字节码文件到运行数据区的方法区

执行引擎：执行字节码文件中的指令

本地方法接口：java调用其他语言的接口，与本地资源交互

运行时数据区：JVM的内存

执行流程

java代码--编译器-->字节码文件--类加载器-->方法区

堆：java.lang.Class对象-->封装方法区内数据结构

每个语言都需要转换成字节码文件，最后转换的字节码文件都能通过Java虚拟机进行运行和处理

随着Java7的正式发布，Java虚拟机的设计者们通过JSR-292规范基本实现在Java虚拟机平台上运行非Java语言编写的程序。

Java虚拟机根本不关心运行在其内部的程序到底是使用何种编程语言编写的，它只关心“字节码”文件

VMware：完全对物理计算机的仿真

专门执行单个计算机程序，JVM：执行Java字节码指令

优点

缺点

地址、操作数

优点

缺点

典型应用是X86的二进制指令集，比如传统的PC以及安卓的Davlik虚拟机

大部分情况下，指令集往往以一地址指令，二地址指令和三地址指令为主。

-v输出附加信息

-l输出行号和本地变量表

-p显示所有类和成员

-c对代码进行反汇编

通过引导类加载器bootstrap class loader创建一个初始类来完成的，这个类是由虚拟机的具体实现指定的。

执行一个所谓的Java程序的时候，真正执行的是一个叫Java虚拟机的进程

程序正常执行结束

执行过程遇到异常或错误而异常终止

操作系统错误导致Java虚拟机进程终止

Runtime类或System类的exit方法、runtime类的halt方法，并且Java安全管理器允许这次exit或halt操作

JNI(Java Native Interface)规范描述了用JNI Invocation API来加载或卸载Java虚拟机时，Java虚拟机退出的情况

常量池运行时加载到内存中，即运行时常量池

加载刚好是加载过程的一个阶段，二者意思不能混淆

通过一个类的全限定名获取定义此类的二进制字节流

将这个字节流所代表的的静态存储结果转化为方法区的运行时数据结构

在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据访问入口

验证

准备

解析

初始化阶段是执行类构造器方法<clinit>()的过程

此方法不需要定义，是javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并而来

构造器方法中指令按照语句在源文中出现的顺序执行

<clinit>()不同于类的构造器（关联：构造器是虚拟机视角下的<init>()）

若该类具有父类，JVM会保证子类的<clinit>()执行前，父类的<clinit>()已经执行完毕

虚拟机必须保证一个类的<clinit>()方法在多线程下被同步加锁

加载、验证、准备、初始化和卸载这五个阶段的顺序是确定的。

解析阶段不一定，在某些情况下可以在初始化阶段之后再开始，为了支持Java语言的运行时绑定特性（也称为动态绑定或晚期绑定）

Java虚拟机规范严格规定了，有且只有六种情况，必须立即对类进行初始化

除了以上几种情况，其他使用类的方式被看做是对类的被动使用，都不会导致类的初始化

启动类加载器(Bootstrap ClassLoader)：用来加载java核心类库，无法被java程序直接引用

扩展类加载器(extensions class loader)：它用来加载 Java 的扩展库。JVM的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类

系统类加载器（system class loader）：它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader()来获取它。

用户自定义类加载器，通过继承 java.lang.ClassLoader类的方式实现

概念上，将所有派生于抽象类ClassLoader的类加载器都划分为自定义加载器

截图

对于用户来说定义器来说，默认使用系统类加载器进行加载

Java的核心类库，使用引导类加载器进行加载

C/C++语言实现，嵌套JVM内部

用来加载Java核心类库，rt.jar,resources.jar,sun.boot.class.path路径下的内容

并不继承java.lang.ClassLoader，没有父加载器

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

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

Java语言编写，由sun.misc.Launcher$ExtClassLoader实现

派生于ClassLoader类

父类加载器为启动类加载器

从java.ext.dirs系统属性所指定的目录中加载类库，或从jre/lib/ext子目录下加载类库

Java语言编写，由sun.misc.Launcher$AppClassLoader实现

派生于ClassLoader类

父类加载器为扩展类加载器

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

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

通过ClassLoader#getSystemClassLoader（）方法可以后去到改类加载器

为什么要用自定义类加载器

实现步骤

是一个抽象类，除了启动类加载器，其他类加载器都继承自他

Java虚拟机对Class文件采用的是按需加载，而且加载class文件时，Java虚拟机使用的是双亲委派模式，即把请求交由父类处理，它是异种任务委派模式

1、如果一个类加载器收到了类加载请求，它并不会自己先去加载。而是把这个请求委托给父类的加载器去执行

2、如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将达到顶层的启动类加载器

3、如果父类的加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式

4、原创整理不易，还请扫码，运行时数据区详图关注支持

避免类的重复加载

保护程序安全，防止核心API被篡改

保证对Java核心源代码的保护

类的完整类名必须一致，包括包名

加载这个类的ClassLoader必须相同

堆：对象分配物理地址不连续，性能相对栈弱些。

栈：先进后出，物理地址连续，性能相对堆好些。

堆：在运行时分配，大小不固定

栈：在编译时分配，大小固定

堆：对象的实例和数组，更关注：数据存储

栈：局部变量，操作数，动态链接，方法返回地址等信息，更关注：程序方法的执行

堆：所有线程共享，可见

栈：线程私有，只对线程可见，生命周期和线程相同

new

Class的newInstance

Constructor的newInstance

使用clone

使用反序列化

第三方库Objenesis

1、判断对象对应的类是否被常量池加载

2、（类加载通过后）为对象分配内存

3、处理并发安全问题

4、初始化分配到的空间

5、设置对象的对象头

6、执行init方法进行初始化

包含两部分

说明：如果是数组，还需要记录数组的长度

对象的实例数据部分，是对象的真正存储的有效信息，即我们在程序代码中定义的各种类型的字段内容，无论是父类继承下来，还是子类中定义的字段都要记录下来。

1、这部分的存储顺序会受到虚拟机分配策略参数和字段在Java源码中定义顺序的影响。
2、分配策略参数-XX:FieldsAllocationStyle
3、HotSpot虚拟机默认的分配顺序为longs/doubles、ints、shorts/chars、bytes/booleans、oops（Ordinary Object Pointers）
4、从默认的分配策略中可以看出，相同宽度的字段总被分配到一起存放。
5、在满足这个前提条件的情况下，在父类中定义的变量会出现在子类之前。
6、如果HotSpot虚拟机的+XX：CompactFields参数值为true（默认也是true），那么子类中较窄的变量也允许插入父类变量的空隙之间，以节省空间。

仅起占位符作用

直接指针：指向对象，代表一个对象在内存中的起始地址。

句柄：可以理解为指向指针的指针，维护着对象的指针。句柄不直接指向对象，而是指向对象的指针（句柄不发生变化，指向固定内存地址），再由对象的指针指向对象的真实内存地址。

句柄池：Java堆，reference中存储：对象的句柄地址，句柄包含对象实例数据、对象类型数据

reference中存储：对象地址，如果访问对象本身，不需要多一次的间接访问的开销。

使用句柄最大好处：reference中存放稳定句柄地址，在对象被移动时（垃圾收集）只改变句柄中实例数据指针，reference本身不改变。

使用指针最大好处：速度快，节省了一次指针定位的时间开销，由于对象访问在Java中非常频繁，所以积少成多也是一项可观的执行成本。

运行时数据区中唯一不会出现OOM的区域，没有垃圾回收。

每个线程有一个私有的程序计数器，线程之间互不影响。

程序计数器会存储当前线程正在执行的Java方法的JVM指令地址

如果正在执行的本地方法，这个计数器值则应为空。（undefined）

使用PC寄存器存储字节码指令地址有什么用

PC寄存器为什么被设定为私有的？

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

生命周期和线程的一致

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

快速有效的存储方式，访问速度仅次于程序计数器

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

栈不存在垃圾回收，但是存在OOM、栈溢出

使用-Xss，MaxStackSize ，设置线程的最大栈空间

每个线程都有自己的栈，栈中的数据以栈帧格式存储

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

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

先进后出，后进先出

一条活动的线程中，一个时间点上，只会有一个活动的栈帧。只有当前正在执行的方法的栈顶栈帧是有效的，这个称为当前栈帧，对应方法是当前方法，对应类是当前类

执行引擎运行的所有字节码指令只针对当前栈帧进行操作

如果方法中调用了其他方法，对应的新的栈帧会被创建出来，放在顶端，成为新的当前帧

不同线程中包含的栈帧不允许存在相互引用。

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

Java方法有两种返回方式

局部变量表

操作数栈

动态链接

方法返回地址

一些附加信息

方法的调用

简单讲，就是一个Java调用非Java代码的接口

与Java环境外交互

内存溢出情况和Java虚拟机栈相同

一个JVM实例只存在一个堆内存

JVM启动就创建，空间大小确定，可调节，参数-Xms，-Xmx

堆内存物理可不连续，逻辑要连续

所有线程共享Java堆，单个线程可以有TLAB

所有对象实例、数组应在运行时分配在堆上

“几乎”所有的对象实例都在堆分配内存。有些对象可能栈上分配：逃逸分析，标量替换

栈帧：保存引用，引用指向对象或数组在堆中的位置

方法结束后，堆中的对象不会马上被移除，仅仅在垃圾回收的时候才会被移除。

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

堆空间细分为：

-XX:+PrintGCDetails 可开启打印查看方法区实现

-Xms9m ：堆空间的起始内存。X执行 memory start

-Xmx9m：堆空间的最大内存。X执行 memory max   超过最大内存将抛出OOM

通常将-Xms和-Xmx两个参数配置相同的值

默认情况下

jps命令   查看当前程序运行的进程

jstat   查看JVM在gc时的统计信息   jstat -gc 进程号

为什么要有新生代和老年代

新生代与老年代空间默认比例1:2

jinfo -flag NewRatio 进程号，查看参数设定值

在HotSpot中，Eden空间和另外两个Survivor空间缺省所占的比例是：8:1:1

为什么新生代被划分为Eden和survivor？

为什么要设置两个survivor区

复制算法也是减少碎片化的过程（减少Eden区，减少survivor区）

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

IBM研究表明，新生代80%的对象都是朝生夕死

-Xmn：设置新生代最大内存大小 memory new。

新生区的对象默认生命周期超过 15 ，就会去养老区养老

1、new的对象先放Eden区，放得下直接放入（此区有大小限制 参数-Xmn 一般默认）

2、当创建新对象，Eden空间填满，会触发一次Minor GC/YGC,young，将Eden不再被其他对象引用的对象进行销毁。将Eden中未销毁的对象移到survive0区。survive0区每个对象都有一个年龄计数器，一次回收还存在的对象，年龄加1

3、如果Eden有空间，加载的新对象放到Eden区（超大对象放不下入老年代）

4、再次eden区满，触发垃圾回收，回收eden＋survive0，幸存下来的放在survive1区，年龄加1

5、再垃圾回收，又会将幸存者重新放回survive0区，依次类推

6、超大对象放入老年代，老年代满或放不下，触发majorGC，再放不下，OOM

7、可以设置存活次数，默认15次，超过15次，对象将从年轻区步入老年区

总结：

触发YGC，幸存者区就会进行回收，不会主动进行回收

幸存区满了咋办？

Visual VM（实时监控 推荐~）

Jprofiler （推荐~）

Java Flight Recorder （实时监控）

jconsole

jvisualvm

说一下 JVM 调优的工具？

针对HotSpotVM的实现

MinorGC的触发条件

老年代GC（MajorGC/FullGC）触发条件

FullGC的触发机制

Minor GC 针对于新生区，Major GC 针对于老年区，Full GC 针对于整个堆空间和方法区

CMS

G1

STW  暂停其它用户的线程，等待垃圾回收线程结束，用户线程才恢复运行

老年代：新生代=2:1

Eden区：from区：to区=8:1:1

可以不分代，分代目的：优化GC性能，避免对所有对象进行扫描，统一对新对象进行管理

如果对象再Eden出生并经过第一次MinorGC后仍然存活，并且能被Survivor区容纳，则被移动到Survivor空间中，并将对象年龄设置为1，对象再Survivor区每熬过一次MinorGC，年龄就+1，当年龄增加到一定程度（默认为15，不同Jvm，GC都所有不同）时，就会被晋升到老年代中

优先分配到Eden

大对象直接分配到老年代

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

动态对象年龄分配

空间分配担保

Thread Local Allocation Buffer

堆区是线程共享区域，任何线程都可以访问到堆区的共享数据

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

为避免多个线程操作（指针碰撞方式分配内存）同一地址，需要使用加锁等机制，进而影响分配速度

TLAB

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

有一种特殊情况，如果经过逃逸分析后发现，一个对象并没有逃逸出方法的话，那么就可能被优化成栈上分配，这样无需堆上分配，也不需要垃圾回收了，也是最常见的堆外存储技术

逃逸分析，未逃逸，栈上分配

标量替换

TaoBaoVM，其中创新的GCIH（GC invisible heap）技术实现了off-heap,实现了将生命周期较长的Java对象从heap中移动heap外，并且GC不能管理GCIH内部的Java对象，以此达到降低GC的回收频率和提升GC的回收效率的目的

逃逸分析概述

-Xms2g

-Xmx2g

-Xmn

-XX:NewRatio=2

-XX:SurviveRatio=8

-XX:MaxTenuringThreshold

-XX:＋UseParNewGC

-XX:+UseParallelGC 

-XX:+UseParallelOldGC

-XX:＋UseConcMarkSweepGC

-XX:+PrintGC：开启打印 gc 信息

-XX:+PrintGCDetails：打印 gc 详细信息

Person 类的 .class 信息存放在方法区中

person 变量存放在 Java 栈的局部变量表中

真正的 person 对象存放在 Java 堆中

在 person 对象中，有个指针指向方法区中的 person 类型数据，表明这个 person 对象是用方法区中的 Person 类 new 出来的

方法区定位

方法区和堆的异同

举例说明方法区OOM

HostSpot可看作方法区永久代等价，本质不等价，《Java虚拟机规范》对如何实现方法区，不做统一要求。

在jdk7及以前，方法区-->永久代，jdk8开始，永久代-->元空间

永久代更容易导致Java程序OOM（超过-XX:MaxPermsize上限）

方法区大小可固定，jvm可根据应用需求动态调整

一般手段：通过内存映像分析工具（如Eclipse Memory Analyzer），对dump出来的堆转存储快照分析，重点确认：内存中的对象是否是必要的。先分清：内存泄露，还是内存溢出

什么是内存泄漏？

若内存泄露，可进一步通过工具查看泄露对象到GC Roots的引用链，于是就能找到内存泄露对象时通过怎样的路径与GC Roots相关联，导致垃圾收集器无法自动回收他们。根据引用链信息，可以较准确的定位出泄露代码的位置

若内存泄漏，导致垃圾回收器无法自动回收原因

如果不存在内存泄露，或者说内存中的对象确实都还必须存活着，那就应当检查虚拟机的堆参数（-Xmx与-Xms），与物理机器内存对比是否还可以调大，从代码检查是否某些对象生命周期过长，持有状态时间过长，尝试减少程序运行时的内存耗用

若内存溢出，jvm参数-Xmx/-Xms 调大，减少程序运行时的内存耗用

方法区存储什么

首先明确，只有HotSpot才有永久代

HotSpot中方法区的变化

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

字符串常量池 StringTable 为什么要调整位置？

静态变量存放在哪里？

常量池中废弃的常量

方法区类的回收

Java 和 C++语言的区别，垃圾收集技术、内存动态分配

三个经典问题

在java中，我们不需要手动释放对象的内存，由JVM的垃圾回收线程自动对没有引用的对象进行回收

创建对象时，GC开始监控这个对象的地址、大小以及使用情况。

GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间

分代复制垃圾回收

标记垃圾回收

增量垃圾回收

垃圾是指在运行程序中没有任何指针指向的对象，这个对象就是需要被回收的垃圾。

An object is considered garbage when it can no longer be reached from any pointer in the running program.

如果不及时对内存中的垃圾进行清理，那么，这些垃圾对象所占的内存空间会一直保留到应用程序结束，被保留的空间无法被其他对象使用。甚至可能导致内存溢出。

不进行垃圾回收，内存会很快消耗完。进行垃圾回收，释放内存空间。

碎片整理，令新对象获得连续的内存空间。

STW的GC无法满足实际需求，需要对GC进行优化。

优点

担忧

垃圾收集器可以对年轻代回收，也可以对老年代回收，甚至是全栈和方法区的回收，其中，Java堆是垃圾收集器的工作重点

次数层面

GC主要关注于方法区和堆中的垃圾收集

在默认情况下，通过System.gc()者Runtime.getRuntime().gc() 的调用，会显式触发Full GC，同时对老年代和新生代进行回收，尝试释放被丢弃对象占用的内存。

System.gc()调用无法保证对垃圾收集器的调用（不能确保立即生效）

JVM实现者可以通过System.gc() 调用来决定JVM的GC行为。而一般情况下，垃圾回收应该是自动进行的，无须手动触发，否则就太过于麻烦。

在一些特殊情况下，如我们正在编写一个性能基准，我们可以在运行之间调用System.gc()

不可达对象回收行为

可以

手动执行System.gc()

通知GC运行，但Java语言规范并不保证GC一定会执行

应用程序占用的内存增长速度非常快，造成垃圾回收已经跟不上内存消耗的速度

GC年轻代老年代的垃圾回收-->内存不足-->独占式Full GC操作-->回收大量内存，供应用程序继续使用。

Javadoc中对OOM的解释：没有空闲内存，并且垃圾收集器也无法提供更多内存。

永久代是在哪个版本去掉的？MetaSpace 是什么时候出现的？MetaSpace 大小一般建议设置为多少？它有可能会爆吗？

如果物理机有 11G 内存，堆设置了 10G，MetaSpace 设置了 128M，它有可能发生 OOM 吗？什么情况会发生？

对内存泄漏有了解吗？

不再被使用的对象或变量一直占据在内存中，但GC又不能回收

内存泄漏，程序不会立刻崩溃，耗尽内存，最终出现OutofMemory异常，导致程序崩溃。

存储空间：虚拟内存大小，取决于磁盘交换区设定的大小

导致内存泄露的原因

内存泄露举例

GC事件发生过程中，会产生应用程序的停顿。停顿产生时整个应用程序线程都会被暂停，没有任何响应，有点像卡死的感觉，这个停顿称为STW。

可达性分析算法中枚举根节点（GC Roots）会导致所有Java执行线程停顿。为什么需要停顿所有 Java 执行线程？

被STW中断的应用程序线程会在完成GC之后恢复，频繁中断令用户体验差，需要减少STW的发生。

注意事项

并发

并行

并发与并行的对比

垃圾回收的并行与串行

安全点（Safepoint）

安全点的中断实现方式

安全区域（Safe Region）

安全区域的执行流程

我们希望能描述这样一类对象：当内存空间还足够时，则能保留在内存中；如果内存空间在进行垃圾收集后还是很紧张，则可以抛弃这些对象。

这4种引用强度依次逐渐减弱。除强引用外，其他3种引用均可以在java.lang.ref包中找到。如图，显示了这3种引用类型对应的类。Reference子类中只有终结器引用是包内可见，其他3种引用类型均为public，可以在应用程序中直接使用

Java 中都有哪些引用类型？

怎么判断对象是否可以被回收？

堆存放：几乎所有的Java对象实例，GC之前：区分对象是否存活

GC执行只回收死亡对象，释放其所占用的内存空间。

标记死亡对象：当一个对象不再被存活的对象引用时

两种方式How：why引用计数算法、可达性分析算法

每个对象上保存整形的引用计数属性，有对象引用计数器加一，减少引用计数器减一。计数器为零时，进行垃圾回收

优点：实现简单、垃圾对象易识别、判定效率高、回收没有延迟性

缺点：循环引用问题

解决循环引用问题，防止内存溢出

分析思路

GC Roots可以是哪些元素？

GC Roots 的总结

小技巧

可达性分析算法的注意事项

子主题

不可达的对象可以被垃圾回收器回收

垃圾回收不会发生在永久代

如果永久代满或超过设定阈值，会触发Full GC（堆+方法区）

查看垃圾收集器的输出信息，会发现永久代也是被回收的

避免Full GC：设置永久代大小，Java8：从永久代到元数据区（本地内存区）

对象销毁前的回调函数：finalize()

finalize() 方法使用的注意事项

由于finalize()方法的存在，虚拟机中的对象有三种可能状态

finalize() 具体执行过程

MAT（Memory Analyzer）：一款功能强大的Java堆内存分析器，用于查找内存泄漏以及查看内存消耗情况。基于Eclipse开发的，是一款免费的性能分析工具

使用JVisualVM捕捉 heap dump

使用 JProfiler 进行 GC Roots 溯源

JProfiler 分析 OOM

标记-清除算法（Mark-Sweep）

复制算法（Copying）

标记-压缩算法（Mark-Compact）

标记-清除算法

复制算法

标记-整理算法

分代算法

执行过程

清除对象的方式

标记-清除算法缺点

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

Eden区、from区、to区的复制算法

复制算法的优点

复制算法的缺点

综上：适合垃圾对象很多，存活对象很少的场景；例如：Young区的Survivor0和Survivor1区

标记-清除算法：老年代，会产生大量内存碎片

复制算法针对：新生代，存活对象少，垃圾对象多。不适用于老年代，大量存活对象

标记-压缩算法的执行流程（标记-清除-压缩）

优点

缺点

年轻代（Young Gen）

老年代（Tenured Gen）

以HotSpot中的CMS回收器为例，CMS是基于Mark-Sweep实现，对于对象的回收效率很高。

对于碎片问题，CMS采用基于Mark-Compact算法的Serial Old回收器作为补偿措施：当内存回收不佳（碎片导致的Concurrent Mode Failure时），将采用Serial Old执行Full GC以达到对老年代内存的整理。

上述现有的算法，在垃圾回收过程中，应用软件将处于一种Stop the World的状态。在Stop the World状态下，应用程序所有的线程都会挂起，暂停一切正常的工作，等待垃圾回收的完成

如果垃圾回收时间过长，应用程序会被挂起很久，将严重影响用户体验或者系统的稳定性。为了解决这个问题，即对实时垃圾收集算法的研究直接导致了增量收集（Incremental Collecting）算法的诞生。

基本思想

增量收集算法的优缺点

一般来说，在相同条件下，堆空间越大，一次GC时所需要的时间就越长，有关GC产生的停顿也越长。

为了更好地控制GC产生的停顿时间，将一块大的内存区域分割成多个小块，根据目标的停顿时间，每次合理地回收若干个小区间，而不是整个堆空间，从而减少一次GC所产生的停顿。

分代算法将按照对象的生命周期长短划分成两个部分，分区算法将整个堆空间划分成连续的不同小区间。每一个小区间都独立使用，独立回收。这种算法的好处是可以控制一次回收多少个小区间。

按线程数分（垃圾回收线程数），可以分为串行垃圾回收器和并行垃圾回收器

按照工作模式分，可以分为并发式垃圾回收器和独占式垃圾回收器

按碎片处理方式分，可分为压缩式垃圾回收器和非压缩式垃圾回收器。

按工作的内存区间分，又可分为年轻代垃圾回收器和老年代垃圾回收器。

吞吐量：运行用户代码的时间占总运行时间的比例（总运行时间 = 程序的运行时间 + 内存回收的时间）

暂停时间：是指一个时间段内应用程序线程暂停，让GC线程执行的状态

一个GC算法只可能针对两个目标之一（即只专注于较大吞吐量或最小暂停时间），或尝试找到一个二者的折衷。现在标准：在最大吞吐量优先的情况下，降低停顿时间

内存占用：Java堆区所占的内存大小。

垃圾收集开销：垃圾收集所用时间与总运行时间的比例。

收集频率：相对于应用程序的执行，收集操作发生的频率。

快速：一个对象从诞生到被回收所经历的时间。

串行回收器：Serial、Serial old

并行回收器：ParNew、Parallel Scavenge、Parallel old

并发回收器：CMS、G1

分代

如何选择垃圾回收器

如何查看默认垃圾收集器

Serial GC（年轻代  Client模式）：复制算法、串行回收、"Stop-the-World"机制

Serial Old GC（老年代 Client模式）：标记-压缩算法、串行回收和"Stop the World"机制

特点

-XX:+UseSerialGC：指定年轻代和老年代都使用串行收集器

区别Serial GC：是否并行

新生代：回收次数频繁，使用并行方式高效

老年代：回收次数少，使用串行方式节省资源（切换线程）

适用范围

设置 ParNew 垃圾回收器

区别ParNew

适用范围

Parallel Old GC：标记-压缩、并行、STW、Java8默认

Parallel Scavenge 回收器参数设置

第一次实现了让垃圾收集线程与用户线程同时工作

匹配：ParNew、Serial GC 无法匹配：Parallel Scavenge

CMS 工作原理

CMS 特点与弊端分析

CMS 参数配置

最小化地使用内存和并行开销：Serial GC

最大化应用程序的吞吐量：Parallel Scavenge GC

最小化GC的中断或停顿时间：CMS  GC

目标：在延迟可控的情况下获得尽可能高的吞吐量

并行性：G1在回收期间，可以有多个GC线程同时工作，有效利用多核计算能力。此时用户线程STW

并发性：G1拥有与应用程序交替执行的能力，部分工作可以和应用程序同时执行，因此，一般来说，不会在整个回收阶段发生完全阻塞应用程序的情况

分代收集

可预测的停顿时间模型

G1 回收器的缺点

G1 参数配置

G1 收集器的常见操作步骤

G1收集器的适用场景

分区 Region：化整为零

G1 垃圾回收流程

新生代回收器：Serial、ParNew、Parallel Scavenge

老年代回收器：Serial Old、Parallel Old、CMS

整堆回收器：G1

7 种垃圾回收器的比较

怎么选择垃圾回收器？

调优永远是针对特定场景、特定需求，不存在一劳永逸的收集器

GC 日志参数设置：通过阅读GC日志，我们可以了解Java虚拟机内存分配与回收策略

内存分配与垃圾回收的参数列表

日志分析的补充说明

Young GC 图例

Full GC 图例

日志分析工具

对于垃圾收集，面试官可以循序渐进从理论、实践各种角度深入，也未必是要求面试者什么都懂。但如果你懂得原理，一定会成为面试中的加分项

较通用、基础性的部分

1、执行引擎在执行的过程中究竟需要执行什么样的字节码指令完全依赖于PC寄存器。

2、每当执行完一项指令操作后，PC寄存器就会更新下一条需要被执行的指令地址

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

JVM在执行Java代码的时候，通常会将解释执行与编译执行二者结合起来进行

各种采用二进制编码方式表示的指令，叫做机器指令码。机器语言。机器指令与CPU紧密相关，不同种类的CPU所对应的机器指令也就不同

由于机器码由01组成，可读性太差。于是人们发明了指令

指令就是把机器码特定的0和1序列，简化成对应的指令，一般为英文编写如mov，inc等，可读性稍好

由于不同的硬件平台，执行同一个操作，对应的机器码可能不同。所以不同的硬件平台的同一种指令，对应的机器码也可能不同

不同硬件平台，各自支持的指令，是有差别的。因此每个平台所支持的指令，称之为对应平台的指令集

x86指令集，对应的x86架构的平台

ARM指令集，对应的是ARM架构的平台

由于指令的可读性太差，于是又有了汇编语言

汇编语言用助记符代替机器指令的操作码，用地址符号或标号，代替指令或操作数的地址。

汇编语言要翻译成机器指令码，计算机才能识别和执行

模板解释器将每一条字节码和一个模板函数相关联，模板函数直接产生这条字节码执行时的机器码，提高解释器的性能

Interpreter模块

Code模块

把.java文件转换为.class文件的过程

把字节码转为机器码的过程

Ahead of Time Compliler AOT，直接把.java文件编译器本地机器代码的过程

需要根据代码被调用执行的频率而定，需要被编译为本地代码的字节码，也称之为热点代码。

JIT编译器会在运行时针对频繁调用的热点代码做出深度优化，将其直接编译为对应平台的本地机器指令。以此提升Java程序的执行性能

一个被多次调用的方法，后者一个方法体内部循环次数较多的循环体，都可以被称之为热点代码

因此可以通过JIT编译器编译为本地机器指令，由于这种编译方法发生在方法的执行过程中，因此也被称之为栈上替换，OSR On Statck Replacement

一个方法调用都少次才能达到标准？这个依靠热点探测功能

client 

server

大多情况下简称C1,C2

-client：指定Java虚拟机在Client模式下，并使用C1编译器

-server：指定虚拟机在server模式下，并使用C2编译器

String s1 = "mogublog" ; // 字面量的定义方式，声明在字符串常量池

String s2 = new String("moxi"); // new 对象的方式

char数组每个字符占两个字节16位，String是堆空间的主要部分，大部分是拉丁字符，占一个字节，节省空间

String再也不用char[] 来存储，改成了byte [] 加上编码标记

StringBuffer，StringBuilder同样做了修改

当字符串重新赋值，需要重写指定内存区域赋值，不能使用原有的value进行赋值

当调用String的replace方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。

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

String的String Pool是一个固定大小的Hashtable，默认值大小长度是1009。如果放进String Pool的String非常多，就会造成Hash冲突严重，从而导致链表会很长，而链表长了后直接会造成的影响就是当调用String.intern()方法时性能会大幅下降。

使用-XX:StringTablesize可设置StringTable的长度

在JDK6中StringTable是固定的，就是1009的长度，所以如果常量池中的字符串过多就会导致效率下降很快，StringTablesize设置没有要求

在JDK7中，StringTable的长度默认值是60013，StringTablesize设置没有要求

在JDK8中，StringTable的长度默认值是60013，StringTable可以设置的最小值为1009

String的常量池比较特殊，主要使用方法有两种

调优时仅需调整堆大小就可以

永久代默认情况下比较小，大量字符串容易导致OOM。

永久代垃圾回收频率低

堆中空间足够大，字符串可被及时回收

+ ：字符串拼接底层

拼接10万次，+号4000，append用了7毫秒，原因是+号每次循环创建一个StringBuilder，还要通过toString创建一个String对象

内存中由于创建了较多的对象，内存占用更大，如果需要GC需要花费额外的时间

改进空间：StringBuilder默认是16长度的char型数组，不够的时候会扩容，可以一次建一个比较大长度的数组。

原因 ① StringBuilder的append()的方式： 自始至终中只创建过一个StringBuilder的对象；使用String的字符串拼接方式：创建过多个StringBuilder和String的对象

原因② 使用String的字符串拼接方式（+）： 内存中由于创建了较多的StringBuilder和String对象，内存占用更大； 如果进行GC，需要花费额外的时间。

改进的空间： 在实际开发中，如果基本确定要前前后后添加的字符串长度不高于某个限定值highLevel的情况下，建议使用构造器实例化

String s = new String("shkstart").intern();

String s = new StringBuilder("shkstart").toString().intern();

一个对象是：new关键字在堆空间创建的

另一个对象是：字符串常量池中的对象"ab"。 字节码指令：ldc

对象1，new StringBuilder()   （有拼接操作）

对象2，new String("a")

对象3，常量池中的"a"

对象4，new String("b")

对象5，常量池中的"b"

对象6，StringBuilder的toString()   new String("ab")

截图（一定要在main方法中测试，@test方式，第二个为false）

jdk1.6中，s.intern()   将这个字符串对象放入串池

jdk1.7起，s.intern()   将这个字符串对象尝试放入串池

案例1

直接 new String ：由于每个 String 对象都是 new 出来的，所以程序需要维护大量存放在堆空间中的 String 实例，程序内存占用也会变高

使用 intern() 方法：由于数组中字符串的引用都指向字符串常量池中的字符串，所以程序需要维护的 String 对象更少，内存占用也更低

对于程序中大量使用存在的字符串时，尤其存在很多已经重复的字符串时，使用intern()方法能够节省内存空间。

大的网站平台，需要内存中存储大量的字符串。比如社交网站，很多人都存储：北京市、海淀区等信息。这时候如果字符串都调用intern() 方法，就会很明显降低内存的大小。

堆存活数据集合里面String对象占了25%

堆存活数据集合里面重复的String对象有13.5%

String对象的平均长度是45