llp-blogJVM基础
1.JVM的位置
JVM是运行在操作系统之上的，它与硬件没有直接的交互
2.JVM体系结构图
这个区域一定不会有垃圾回收
所谓JVM的调优，其实就是在调这个区域，而且99%情况下都在调堆 !
3.类加载器ClassLoader
先来看看一个类加载到 JVM 的一个基本结构：
在如下几种情况下，Java虚拟机将结束生命周期：
- 执行了System.exit()方法
- 程序正常执行结束
- 程序在执行过程中遇到了异常或者错误而异常终止
- 由于操作系统出现错误而导致Java虚拟机进行终止
3.1 类的加载、连接与初始化
在Java代码中，Class的加载、连接与初始化过程都是在程序运行期间完成的。Runtime！
加载： 查找并加载类的二进制数据
连接
- 验证：确保被加载的类的正确性
- 准备：为类的静态变量分配内存，并将其初始化为默认值
- 解析：把类中的符号引用转换为直接引用
在编译的时候每个java类都会被编译成一个class文件，但在编译的时候虚拟机并不知道所引用类的地址，所以就用符号引用来代替，而在这个解析阶段就是为了把这个符号引用转化
成为真正的地址的阶段。
- 初始化：为类的静态变量赋予正确的初始值
从代码来理解：
class Test{
public static int a = 1;
}
//我们程序中给定的是 public static int a = 1;
//但是在加载过程中的步骤如下：
1. 加载阶段
编译文件为 .class文件，然后通过类加载，加载到JVM
2. 连接阶段
第一步（验证）：确保Class类文件没问题
第二步（准备）：先初始化为 a=0。（因为你int类型的初始值为0）
第三步（解析）：将引用转换为直接引用
3. 初始化阶段：
通过此解析阶段，把1赋值为变量aclass Test{
public static int a = 1;
}
//我们程序中给定的是 public static int a = 1;
//但是在加载过程中的步骤如下：
1. 加载阶段
编译文件为 .class文件，然后通过类加载，加载到JVM
2. 连接阶段
第一步（验证）：确保Class类文件没问题
第二步（准备）：先初始化为 a=0。（因为你int类型的初始值为0）
第三步（解析）：将引用转换为直接引用
3. 初始化阶段：
通过此解析阶段，把1赋值为变量a3.2类的加载
类的加载指的是将类的.class文件中二进制数据读入到内存中，将其放在运行时数据区内的方法区内，然
后再内存中创建一个 java.lang.Class 对象用来封装类在方法区内的数据结构。
//对于静态字段来说，只有直接定义了该字段的类才会被初始化；
//当一个类在初始化时，要求其父类全部都已经初始化完毕了；
//所有Java虚拟机实现必须在每个类或者接口被Java程序“首次主动使用”时才初始化他们
public class MyTest1 {
public static void main (String[] args){
System.out.println(MyChild1.str2);
}
}
class MyParent1{
public static String str = "hello world";
static {
System.out.println("MyParent1 static");
}
}
class MyChild1 extends MyParent1{
public static String str2 = "welcome";
static{
System.out.println("MyChild1 static");
}
}
// 输出结果：
MyParent1 static block
MyChild1 static block
welcome//对于静态字段来说，只有直接定义了该字段的类才会被初始化；
//当一个类在初始化时，要求其父类全部都已经初始化完毕了；
//所有Java虚拟机实现必须在每个类或者接口被Java程序“首次主动使用”时才初始化他们
public class MyTest1 {
public static void main (String[] args){
System.out.println(MyChild1.str2);
}
}
class MyParent1{
public static String str = "hello world";
static {
System.out.println("MyParent1 static");
}
}
class MyChild1 extends MyParent1{
public static String str2 = "welcome";
static{
System.out.println("MyChild1 static");
}
}
// 输出结果：
MyParent1 static block
MyChild1 static block
welcome查看类的加载信息，并打印出来：
jvm 参数介绍：
-XX:+TraceClassLoading,用于追踪类的加载信息并打印出来。
所有的参数都是：
-XX:+<option> ， 表示开启option选项
-XX:-<option> ， 表示关闭option选项
-XX:+<option>=<value> 表示将option选项的值设置为valuejvm 参数介绍：
-XX:+TraceClassLoading,用于追踪类的加载信息并打印出来。
所有的参数都是：
-XX:+<option> ， 表示开启option选项
-XX:-<option> ， 表示关闭option选项
-XX:+<option>=<value> 表示将option选项的值设置为value
3.3常量池的概念
先来看一道题
public class MyTest2 {
public static void main(String[] args) {
System.out.println(MyParent2.str);
}
}
class MyParent2 {
public static final String str = "hello world";
static {
System.out.println("Myparent2 static block");// 这一行能输出吗？不会
}
}
//输出结果
//hello worldpublic class MyTest2 {
public static void main(String[] args) {
System.out.println(MyParent2.str);
}
}
class MyParent2 {
public static final String str = "hello world";
static {
System.out.println("Myparent2 static block");// 这一行能输出吗？不会
}
}
//输出结果
//hello world常量在编译阶段会存入到调用这个常量的方法所在的类的常量池中 本质上，调用类并没有直接用用到定义常量的类，因此并不会触发定义常量的类的初始化。 注意：这里指的是将常量存放到了MyTest2的常量池中，之后MyTest2与MyParent2就没有任何关系了。
再看一道题，类的初始化规则
/*
* 当一个常量的值并非编译期间可以确定的，那么其值就不会被放到调用类的常量池中，
这是在程序运行时，会导致主动使用这个常量所在的类，显然就会导致这个类被初始化。
*/
public class MyTest3 {
public static void main(String[] args) {
System.out.println(MyParent3.str);
}
}
class MyParent3 {
public static final String str = UUID.randomUUID().toString();
static {
System.out.println("Myparent3 static block"); // 这一行能输出吗？会
}
}
//输出结果
//Myparent3 static block
//cdb8c888-626c-4a38-bb86-b036d5618df5/*
* 当一个常量的值并非编译期间可以确定的，那么其值就不会被放到调用类的常量池中，
这是在程序运行时，会导致主动使用这个常量所在的类，显然就会导致这个类被初始化。
*/
public class MyTest3 {
public static void main(String[] args) {
System.out.println(MyParent3.str);
}
}
class MyParent3 {
public static final String str = UUID.randomUUID().toString();
static {
System.out.println("Myparent3 static block"); // 这一行能输出吗？会
}
}
//输出结果
//Myparent3 static block
//cdb8c888-626c-4a38-bb86-b036d5618df5为什么第二个例子不会输出，第三个例子就输出了呢？
因为第三个例子的值，是只有当运行期才会被确定的值。而第二个例子的值，是编译时就能被确定的值。
3.4ClassLoader分类
有两种类型的类加载器
1、Java虚拟机自带的加载器
根类加载器（BootStrap）(BootClassLoader) sun.boot.class.path （加载系统的包，包含jdk核心库里的类）
扩展类加载器（Extension）（ExtClassLoader） java.ext.dirs（加载扩展jar包中的类）
系统（应用）类加载器（System）(AppClassLoader) java.class.path（加载你编写的类，编译后的类）
2、用户自定义的类加载器
Java.long.ClassLoader的子类（继承），用户可以定制类的加载方式
代码测试
public class ClassLoaderDemo01 {
public static void main(String[] args) {
Object object = new Object();
ClassLoaderDemo01 demo01 = new ClassLoaderDemo01();
System.out.println(object.getClass().getClassLoader());
System.out.println(demo01.getClass().getClassLoader());
System.out.println(demo01.getClass().getClassLoader().getParent());
System.out.println(demo01.getClass().getClassLoader().getParent().getParent());
}
}
/*
结果：
null
sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@1b6d3586
null
**/public class ClassLoaderDemo01 {
public static void main(String[] args) {
Object object = new Object();
ClassLoaderDemo01 demo01 = new ClassLoaderDemo01();
System.out.println(object.getClass().getClassLoader());
System.out.println(demo01.getClass().getClassLoader());
System.out.println(demo01.getClass().getClassLoader().getParent());
System.out.println(demo01.getClass().getClassLoader().getParent().getParent());
}
}
/*
结果：
null
sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@1b6d3586
null
**/3.5 双亲委派机制
双亲委派机制的工作原理：一层一层的 让父类去加载，最顶层父类不能加载往下数，依次类推。
- 类加载器收到类加载的请求；
- 把这个请求委托给父加载器去完成，一直向上委托，直到启动类加载器；
- 启动器加载器检查能不能加载（使用findClass()方法），能就加载（结束）；否则，抛出异常，通知子加载器进行加载。
- 重复步骤三；
代码测试：
public class String {
public static void main(String[] args) {
System.out.println(1);
}
}public class String {
public static void main(String[] args) {
System.out.println(1);
}
}
String 默认情况下是启动类加载器进行加载的。假设我也自定义一个String 。现在你会发现自定义的String 可以正常编译，但是永远无法被加载运行。
这是因为申请自定义String 加载时，总是启动类加载器，而不是自定义加载器，也不会是其他的加载器。
双亲委派机制可以确保Java核心类库所提供的类，不会被自定义的类所替代。
双亲委派机制存在的意义 1.通过委派的方式，可以避免类的重复加载，当父加载器已经加载过某一个类时，子加载器就不会再重新加载这个类。 2.通过双亲委派的方式，还保证了安全性。因为Bootstrap ClassLoader在加载的时候，只会加载JAVA_HOME中的jar包里面的类，如java.lang.Integer，那么这个类是不会被随意替换的，除非有人跑到你的机器上， 破坏你的JDK。那么，就可以避免有人自定义一个有破坏功能的java.lang.Integer被加载。这样可以有效的防止核心Java API被篡改。 双亲委派机制是在classLoader里的loadclass方法里实现的， 源码： 简单说下实现流程：
首先判断该类是否已经被加载 2.该类未被加载，如果父类不为空，交给父类加载 3.如果父类为空，交给bootstrap classloader 加载 4.如果类还是无法被加载到，则触发findclass,抛出classNotFoundException(findclass这个方法当前只有一个语句，就是抛出classNotFoundException），如果想自己实现类加载器的话，可以继承classLoader后重写findclass方法，加载对应的类）
4.Native方法
编写一个多线程类启动
public class MyTest {
public static void main(String[] args) {
new Thread(() -> {
}, "your thread name").start();
}
}public class MyTest {
public static void main(String[] args) {
new Thread(() -> {
}, "your thread name").start();
}
}点进去看start方法的源码
public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented. */
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
//凡是带了native关键字的，说明 java的作用范围达不到，去调用底层C语言的库！
private native void start0();public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented. */
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
//凡是带了native关键字的，说明 java的作用范围达不到，去调用底层C语言的库！
private native void start0();JNI：Java Native Interface （Java本地方法接口）
凡是带了native关键字的方法就会进入本地方法栈；
本地接口的作用是融合不同的编程语言为Java所用，它的初衷是融合C/C++程序，Java在诞生的时候是 C/C++横行的时候，想要立足，必须有调用C、C++的程序，于是就在内存中专门开辟了一块区域处理标 记为native的代码，它的具体做法是 在 Native Method Stack 中登记native方法，在 ( ExecutionEngine ) 执行引擎执行的时候加载Native Libraies。
5.程序计数器
程序计数器：Program Counter Register
每个线程都有一个程序计数器，是线程私有的。
程序计数器是一块较小的内存空间，它的作用可以看作是当前线程所执行的字节码的行号指示器。在虚
拟机的概念模型里字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指
令，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。是一个非常小
的内存空间，几乎可以忽略不计
public class Calc {
public int calc() {
int a = 100;
int b = 200;
int c = 300;
return (a + b) * c;
}
}public class Calc {
public int calc() {
int a = 100;
int b = 200;
int c = 300;
return (a + b) * c;
}
}反编译： Javap -c xx.class反编译之后会有助记符。
ldc 表示将int、flfloat或是String类型的常量值从常量池中推送至栈顶。
bipush 表示将单字节（-128~127）的常量值推送至栈顶。
sipush 表示将短整型(-32767~32768)的常量值推送至栈顶。
istore_1 将一个数值从操作数栈存储到局部变量表
iadd 加
imul 乘
图中使用红框框起来的就是字节码指令的偏移地址，偏移地址对应的bipush 等等是jvm 中的操作指令,
这是入栈指令。 当执行到方法**calc()**时在当前的线程中会创建相应的程序计数器，在计数器中为存放执
行地址 （红框中的）0 2 3…等等
6.方法区
Method Area 方法区 是 Java虚拟机规范 中定义的运行时数据区域之一，它与堆(heap)一样在线程之间
共享。
Java 虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却有一个别名叫做 Non-Heap（非堆），目
的应该是与 Java 堆区分开来。
JDK7 之前（永久代）用于存储已被虚拟机加载的类信息、常量、字符串常量、类静态变量、即时编译器
编译后的代码等数据。每当一个类初次被加载的时候，它的元数据都会被放到永久代中。永久代大小有
限制，如果加载的类太多，很可能导致永久代内存溢出，即 java.lang.OutOfMemoryError:
PermGen。
JDK8 彻底将永久代移除出 HotSpot JVM，将其原有的数据迁移至 Java Heap 或 Native
Heap（Metaspace），取代它的是另一个内存区域被称为元空间（Metaspace）。
元空间（Metaspace）：元空间是方法区的在 HotSpot JVM 中的实现，方法区主要用于存储类信息、常
量池、方法数据、方法代码、符号引用等。元空间的本质和永久代类似，都是对 JVM 规范中方法区的实
现。不过元空间与永久代之间最大的区别在于：元空间并不在虚拟机中，而是使用本地内存。
可以通过 -XX:MetaspaceSize 和 -XX:MaxMetaspaceSize 配置内存大小。
如果Metaspace的空间占用达到了设定的最大值，那么就会触发GC来收集死亡对象和类的加载器。
7.栈（Stack）
栈和队列
栈：后进先出 / 先进后出
队列：先进先出（FIFO : First Input First Output）
Stack 栈是什么
栈管理程序运行
存储一些基本类型的值、对象的引用、方法等。
栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。
思考：为什么main方法最后执行！为什么一个test() 方法执行完了，才会继续走main方法！
说明：
1、栈也叫栈内存，主管Java程序的运行，是在线程创建时创建，它的生命期是跟随线程的生命期，线程
结束栈内存也就释放。
2、对于栈来说不存在垃圾回收问题，只要线程一旦结束，该栈就Over，生命周期和线程一致，是线程
私有的。
3、方法自己调自己就会导致栈溢出（递归死循环测试）
public class StackDemo {
public static void main(String[] args) {
a();
}
public static void a() {
b();
}
public static void b() {
a();
}
}
//Exception in thread "main" java.lang.StackOverflowErrorpublic class StackDemo {
public static void main(String[] args) {
a();
}
public static void a() {
b();
}
public static void b() {
a();
}
}
//Exception in thread "main" java.lang.StackOverflowError栈运行原理
Java栈的组成元素—栈帧
栈帧是一种用于帮助虚拟机执行方法调用与方法执行的数据结构。他是独立于线程的，一个线程有自己
的一个栈帧。封装了方法的局部变量表、动态链接信息、方法的返回地址以及操作数栈等信息。
第一个方法从调用开始到执行完成，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。
当一个方法A被调用时就产生了一个栈帧F1，并被压入到栈中，A方法又调用了B方法，于是产生了栈帧
F2也被压入栈中，B方法又调用了C方法，于是产生栈帧F3也被压入栈中.........执行完毕后，先弹出F3，
然后弹出F2，在弹出F1........
遵循 “先进后出” / "后进先出" 的原则。
什么是HotSpot？
了解三种JVM： Sun公司的 HotSpot BEA公司的 JRockit IBM公司的 J9VM
8.堆（Heap）
Java7之前 Heap 堆，一个JVM实例只存在一个堆内存，堆内存的大小是可以调节的，类加载器读取了类文件后，需 要把类，方法，常变量放到堆内存中，保存所有引用类型的真实信息，以方便执行器执行，堆内存分为 三部分： 新生区 Young Generation Space Young/New 养老区 Tenure generation space Old/Tenure 永久区 Permanent Space Perm 堆内存逻辑上分为三部分：新生，养老，永久（元空间 : JDK8 以后名称）
GC垃圾回收主要是在 新生区和养老区，又分为 轻GC 和 重GC，如果内存不够，或者存在死循环，就会 导致 java.lang.OutOfMemoryError: Java heap space
新生区
新生区是类诞生，成长，消亡的区域，一个类在这里产生，应用，最后被垃圾回收器收集，结束生命。
新生区又分为两部分：伊甸区（Eden Space）和幸存者区（Survivor Space），所有的类都是在伊甸区
被new出来的，幸存区有两个：0区 和 1区，当伊甸园的空间用完时，程序又需要创建对象，JVM的垃圾
回收器将对伊甸园区进行垃圾回收（Minor GC）。将伊甸园中的剩余对象移动到幸存0区，若幸存0区也
满了，再对该区进行垃圾回收，然后移动到1区，那如果1区也满了呢？（这里幸存0区和1区是一个互相
交替的过程）再移动到养老区，若养老区也满了，那么这个时候将产生MajorGC（Full GC），进行养老
区的内存清理，若养老区执行了Full GC后发现依然无法进行对象的保存，就会产生OOM异常
“OutOfMemoryError ”。
如果出现 java.lang.OutOfMemoryError：java heap space异常，说明Java虚拟机的堆内存不够，原因
如下：
1、Java虚拟机的堆内存设置不够，可以通过参数 -Xms（初始值大小），-Xmx（最大大小）来调整。
2、代码中创建了大量大对象，并且长时间不能被垃圾收集器收集（存在被引用）或者死循环
Sun HotSpot内存管理
分代管理，不同的区域使用不同的算法：
Why？真相：经过研究，不同对象的生命周期不同，在Java中98%的对象都是临时对象。
永久区（Perm）
永久存储区是一个常驻内存区域，用于存放JDK自身所携带的Class，Interface的元数据，也就是说它存
储的是运行环境必须的类信息，被装载进此区域的数据是不会被垃圾回收器回收掉的，关闭JVM才会释
放此区域所占用的内存。
如果出现 java.lang.OutOfMemoryError：PermGen space，说明是 Java虚拟机对永久代Perm内存设
置不够。一般出现这种情况，都是程序启动需要加载大量的第三方jar包，例如：在一个Tomcat下部署
了太多的应用。或者大量动态反射生成的类不断被加载，最终导致Perm区被占满。
注意：
Jdk1.6之前： 有永久代，常量池1.6在方法区
Jdk1.7： 有永久代，但是已经逐步 “去永久代”，常量池1.7在堆
Jdk1.8及之后：无永久代，常量池1.8在元空间
熟悉三区结构后方可学习JVM垃圾回收机制
实际而言，方法区（Method Area）和堆一样，是各个线程共享的内存区域，它用于存储虚拟机加载 的：类信息+普通常量+静态常量+编译器编译后的代码，虽然JVM规范将方法区描述为堆的一个逻辑部 分，但它却还有一个别名，叫做Non-Heap（非堆），目的就是要和堆分开。 对于HotSpot虚拟机，很多开发者习惯将方法区称之为 “永久代（Parmanent Gen）”，但严格本质上说 两者不同，或者说使用永久代实现方法区而已，永久代是方法区（相当于是一个接口interface）的一个 实现，Jdk1.7的版本中，已经将原本放在永久代的字符串常量池移走。 常量池（Constant Pool）是方法区的一部分，Class文件除了有类的版本，字段，方法，接口描述信息 外，还有一项信息就是常量池，这部分内容将在类加载后进入方法区的运行时常量池中存放！
9.堆内存调优
先看下 JDK 1.7 的 和 1.8 的区别
JDK 1.8 的
使用 IDEA 调整堆内存大小测试
堆内存调优
-Xms ：设置初始分配大小，默认为物理内存的 “1/64”
-Xmx ：最大分配内存，默认为物理内存的 “1/4”
-XX:+PrintGCDetails ：输出详细的GC处理日志
代码测试
测试一
public class Demo01 {
public static void main(String[] args) {
//返回Java虚拟机试图使用的最大内存量
long maxMemory = Runtime.getRuntime().maxMemory();
//返回Java虚拟机中的内存总量
long totalMemory = Runtime.getRuntime().totalMemory();
System.out.println("MAX_MEMORY=" + maxMemory + "(字节)、"
+ (maxMemory / (double) 1024 / 1024) + "MB");
System.out.println("TOTAL_MEMORY=" + totalMemory + "(字节)、"
+ (totalMemory / (double) 1024 / 1024) + "MB");
}
}
//数据结果
//MAX_MEMORY=5693243392(字节)、5429.5MB
//TOTAL_MEMORY=384303104(字节)、366.5MBpublic class Demo01 {
public static void main(String[] args) {
//返回Java虚拟机试图使用的最大内存量
long maxMemory = Runtime.getRuntime().maxMemory();
//返回Java虚拟机中的内存总量
long totalMemory = Runtime.getRuntime().totalMemory();
System.out.println("MAX_MEMORY=" + maxMemory + "(字节)、"
+ (maxMemory / (double) 1024 / 1024) + "MB");
System.out.println("TOTAL_MEMORY=" + totalMemory + "(字节)、"
+ (totalMemory / (double) 1024 / 1024) + "MB");
}
}
//数据结果
//MAX_MEMORY=5693243392(字节)、5429.5MB
//TOTAL_MEMORY=384303104(字节)、366.5MB发现，默认的情况下分配的内存是总内存的 1/4，而初始化的内存为 1/64 ！
-Xms1024m -Xmx1024m -XX:+PrintGCDetails-Xms1024m -Xmx1024m -XX:+PrintGCDetailsVM参数调优：把初始内存，和总内存都调为 1024M，运行，查看结果！
我们来大概计算分析一下！
新生代+老年代=981.5MB，再次证明：元空间并不在虚拟机中，而是使用本地内存。
测试二
public class Demo02 {
public static void main(String[] args) {
String str = "Java";
while (true) {
str += str + new Random().nextInt(88888888)
+ new Random().nextInt(999999999);
}
}
}public class Demo02 {
public static void main(String[] args) {
String str = "Java";
while (true) {
str += str + new Random().nextInt(88888888)
+ new Random().nextInt(999999999);
}
}
}vm参数：
-Xms8m -Xmx8m -XX:+PrintGCDetails-Xms8m -Xmx8m -XX:+PrintGCDetails测试，查看结果！
这是一个young 区域撑爆的JAVA 内存日志，其中 PSYoungGen 表示 youngGen分区的变化，从第一行开始看
1536k 表示 GC 之前的大小。
488k 表示GC 之后的大小。
整个Young区域的大小从 1536K 到 624K , young代的总大小为 7680K。
[Times: user=0.02 sys=0.00, real=0.01 secs]
user – 总计本次 GC 总线程所占用的总 CPU 时间
sys – 0S 调用 or 等待系统时间
real – 应用暂停时间
如果GC 线程是 Serial Garbage Collector 串行搜集器的方式的话（只有一条GC线程,）， real time 等于user 和 system 时间之和。
通过日志发现Young的区域到最后 GC 之前后都是0，old 区域 无法释放，最后报堆溢出错误。
10.Dump内存快照
在运行java程序的时候，有时候想测试运行时占用内存情况，这时候就需要使用测试工具查看了。在 eclipse里面有 Eclipse Memory Analyzer tool(MAT)插件可以测试，而在idea中也有这么一个插件， 就是JProfiler，一款性能瓶颈分析工具！ 作用： 分析Dump文件，快速定位内存泄漏； 获得堆中对象的统计数据 获得对象相互引用的关系 采用树形展现对象间相互引用的情况 ...... 而且这个软件跨平台：
安装JProfifiler
- IDEA插件安装
- 安装JProfifiler监控软件
下载地址：https://www.ej-technologies.com/download/jprofifiler/version_92
- 注册
// 注册码仅供大家参考
L-Larry_Lau@163.com#23874-hrwpdp1sh1wrn#0620
L-Larry_Lau@163.com#36573-fdkscp15axjj6#25257
L-Larry_Lau@163.com#5481-ucjn4a16rvd98#6038
L-Larry_Lau@163.com#99016-hli5ay1ylizjj#27215
L-Larry_Lau@163.com#40775-3wle0g1uin5c1#0674// 注册码仅供大家参考
L-Larry_Lau@163.com#23874-hrwpdp1sh1wrn#0620
L-Larry_Lau@163.com#36573-fdkscp15axjj6#25257
L-Larry_Lau@163.com#5481-ucjn4a16rvd98#6038
L-Larry_Lau@163.com#99016-hli5ay1ylizjj#27215
L-Larry_Lau@163.com#40775-3wle0g1uin5c1#0674- 配置IDEA运行环境
如何使用jprofile分析堆dump文件？
public class Demo03 {
byte[] byteArray = new byte[1 * 1024 * 1024]; //1M = 1024K
public static void main(String[] args) {
ArrayList<Demo03> list = new ArrayList<>();
int count = 0;
try {
while (true) {
list.add(new Demo03());
count = count + 1;
}
} catch (Error e) {
System.out.println("count:" + count);
e.printStackTrace();
}
}
}public class Demo03 {
byte[] byteArray = new byte[1 * 1024 * 1024]; //1M = 1024K
public static void main(String[] args) {
ArrayList<Demo03> list = new ArrayList<>();
int count = 0;
try {
while (true) {
list.add(new Demo03());
count = count + 1;
}
} catch (Error e) {
System.out.println("count:" + count);
e.printStackTrace();
}
}
}vm参数 ：-Xms1m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError
运行结果：
寻找文件：
使用 Jprofifiler 工具分析查看，双击这个文件默认使用 Jprofifiler 进行 Open
具体的 Jprofifiler 使用参考：https://www.cnblogs.com/jpfss/p/8488111.html
11.GC详解
分代（新生代、老年代）收集算法次数频繁Young区，次数较少Old区，基本不动Perm（永久区）区
GC算法总体概述
先看下一个对象的历程：
JVM 在进行GC时，并非每次都对上面三个内存区域一起回收的，大部分时候回收的都是指新生代 因此GC按照回收的区域又分了两种类型，一种是普通的GC（minor GC），一种是全局GC （major GCor Full GC） 普通GC：只针对新生代区域的GC 全局GC：针对老年代的GC，偶尔伴随对新生代的GC以及对永久代的GC
GC面试题
1、JVM内存模型以及分区，需要详细到每个区放什么
2、堆里面的分区：Eden，Survival from to，老年代，各自的特点。
3、GC的三种收集方法：标记清除，标记整理，复制算法的原理与特点，分别用在什么地方？
4、Minor GC 与 Full GC 分别在什么时候发生?
12.GC四大算法
引用计数法 (说明：了解即可！)
每个对象有一个引用计数器，当对象被引用一次则计数器加1，当对象引用失效一次，则计数器减1，对
于计数器为0的对象意味着是垃圾对象，可以被GC回收。
目前虚拟机基本都是采用可达性算法，从GC Roots 作为起点开始搜索，那么整个连通图中的对象边都是
活对象，对于GC Roots 无法到达的对象变成了垃圾回收对象，随时可被GC回收。
复制算法（Copying）
年轻代中使用的是Minor GC，采用的就是复制算法（Copying）什么是复制算法？
Minor GC 会把Eden中的所有活的对象都移到Survivor区域中，如果Survivor区中放不下，那么剩下的
活的对象就被移动到Old generation中，也就是说，一旦收集后，Eden就是变成空的了
当对象在Eden（包括一个Survivor区域，这里假设是From区域）出生后，在经过一次Minor GC后，如
果对象还存活，并且能够被另外一块Survivor区域所容纳 （上面已经假设为from区域，这里应为to区
域，即to区域有足够的内存空间来存储Eden 和 From 区域中存活的对象），则使用复制算法将这些仍然
还活着的对象复制到另外一块Survivor区域（即 to 区域）中，然后清理所使用过的Eden 以及Survivor
区域（即form区域），并且将这些对象的年龄设置为1，以后对象在Survivor区，每熬过一次Minor
GC，就将这个对象的年龄 + 1，当这个对象的年龄达到某一个值的时候（默认是15岁，通过-
XX:MaxTenuringThreshold 设定参数）这些对象就会成为老年代。
-XX:MaxTenuringThreshold 任期门槛=>设置对象在新生代中存活的次数
面试题：如何判断哪个是to区呢？一句话：谁空谁是to
原理解释：
年轻代中的GC，主要是复制算法（Copying）
HotSpot JVM 把年轻代分为了三部分：一个 Eden 区 和 2 个Survivor区（from区 和 to区）。默认比例
为 8:1:1，一般情况下，新创建的对象都会被分配到Eden区（一些大对象特殊处理），这些对象经过第
一次Minor GC后，如果仍然存活，将会被移到Survivor区，对象在Survivor中每熬过一次Minor GC ，
年龄就会增加1岁，当它的年龄增加到一定程度时，就会被移动到年老代中，因为年轻代中的对象基本上
都是朝生夕死，所以在年轻代的垃圾回收算法使用的是复制算法！复制算法的思想就是将内存分为两
块，每次只用其中一块，当这一块内存用完，就将还活着的对象复制到另外一块上面。复制算法不会产
生内存碎片！
在GC开始的时候，对象只会在Eden区和名为 “From” 的Survivor区，Survivor区“TO” 是空的，紧接着进
行GC，Eden区中所有存活的对象都会被复制到 “To” ， 而在 “From” 区中，仍存活的对象会更具他们的
年龄值来决定去向。年龄达到一定值 的对象会被移动到老年代中，没有达到阈值的对象会被复制到 “To
区域”，经过这次GC后，Eden区和From区已经被清空，这个时候， “From” 和 “To” 会交换他们的角色，
也就是新的 “To“ 就是GC前的”From“ ， 新的 ”From“ 就是上次GC前的 ”To“。不管怎样，都会保证名为
To 的Survicor区域是空的。 Minor GC会一直重复这样的过程。直到 To 区 被填满 ， ”To “ 区被填满之
后，会将所有的对象移动到老年代中。
因为Eden区对象一般存活率较低，一般的，使用两块10%的内存作为空闲和活动区域，而另外80%的内
存，则是用来给新建对象分配内存的。一旦发生GC，将10%的from活动区间与另外80%中存活的Eden
对象转移到10%的to空闲区域，接下来，将之前的90%的内存，全部释放，以此类推；
好处：没有内存碎片，坏处：浪费内存空间
劣势：
复制算法它的缺点也是相当明显的。
1、他浪费了一半的内存，这太要命了
2、如果对象的存活率很高，我们可以极端一点，假设是100%存活，那么我们需要将所有对象都复制一
遍，并将所有引用地址重置一遍。复制这一工作所花费的时间，在对象存活率达到一定程度时，将会变
的不可忽视，所以从以上描述不难看出。复制算法要想使用，最起码对象的存活率要非常低才行，而且
最重要的是，我们必须要克服50%的内存浪费。
标记清除（Mark-Sweep）
说明：老年代一般是由标记清除或者是标记清除与标记整理的混合实现
什么是标记清除？
回收时，对需要存活的对象进行标记；
回收不是绿色的对象
当堆中的有效内存空间被耗尽的时候，就会停止整个程序（也被称为stop the world），然后进行两项
工作，第一项则是标记，第二项则是清除。
标记：从引用根节点开始标记所有被引用的对象，标记的过程其实就是遍历所有的GC Roots ，然后将所
有GC Roots 可达的对象，标记为存活的对象。
清除： 遍历整个堆，把未标记的对象清除。
缺点：这个算法需要暂停整个应用，会产生内存碎片。
用通俗的话解释一下 标记/清除算法，就是当程序运行期间，若可以使用的内存被耗尽的时候，GC线程
就会被触发并将程序暂停，随后将依旧存活的对象标记一遍，最终再将堆中所有没被标记的对象全部清
除掉，接下来便让程序恢复运行。
劣势：
- 首先、它的缺点就是效率比较低（递归与全堆对象遍历），而且在进行GC的时候，需要停止应用
程序，这会导致用户体验非常差劲
- 其次、主要的缺点则是这种方式清理出来的空闲内存是不连续的，这点不难理解，我们的死亡对象
都是随机的出现在内存的各个角落，现在把他们清除之后，内存的布局自然乱七八糟，而为了应付
这一点，JVM就不得不维持一个内存空间的空闲列表，这又是一种开销。而且在分配数组对象的时
候，寻找连续的内存空间会不太好找。
标记压缩（Mark-Compact）
标记整理说明：老年代一般是由标记清除或者是标记清除与标记整理的混合实现。
什么是标记压缩？
在整理压缩阶段，不再对标记的对象作回收，而是通过所有存活对象都像一端移动，然后直接清除边界
以外的内存。可以看到，标记的存活对象将会被整理，按照内存地址依次排列，而未被标记的内存会被
清理掉，如此一来，当我们需要给新对象分配内存时，JVM只需要持有一个内存的起始地址即可，这比
维护一个空闲列表显然少了许多开销。
标记、整理算法不仅可以弥补 标记、清除算法当中，内存区域分散的缺点，也消除了复制算法当中，内
存减半的高额代价；
标记清除压缩（Mark-Sweep-Compact）
小总结
内存效率：复制算法 > 标记清除算法 > 标记整理算法 （时间复杂度）
内存整齐度：复制算法 = 标记整理算法 > 标记清除算法
内存利用率：标记整理算法 = 标记清除算法 > 复制算法
可以看出，效率上来说，复制算法是当之无愧的老大，但是却浪费了太多内存，而为了尽量兼顾上面所
提到的三个指标，标记整理算法相对来说更平滑一些 ， 但是效率上依然不尽如人意，它比复制算法多了
一个标记的阶段，又比标记清除多了一个整理内存的过程。
难道就没有一种最优算法吗？猜猜看，下面还有
答案 ： 无，没有最好的算法，只有最合适的算法 。 -----------------> 分代收集算法
年轻代：（Young Gen）
年轻代特点是区域相对老年代较小，对象存活低。
这种情况复制算法的回收整理，速度是最快的。复制算法的效率只和当前存活对象大小有关，因而很适
用于年轻代的回收。而复制算法内存利用率不高的问题，通过hotspot中的两个survivor的设计得到缓解。
老年代：（Tenure Gen）
老年代的特点是区域较大，对象存活率高！
这种情况，存在大量存活率高的对象，复制算法明显变得不合适。一般是由标记清除或者是标记清除与
标记整理的混合实现。Mark阶段的开销与存活对象的数量成正比，这点来说，对于老年代，标记清除或
者标记整理有一些不符，但可以通过多核多线程利用，对并发，并行的形式提标记效率。Sweep阶段的
开销与所管理里区域的大小相关，但Sweep “就地处决” 的 特点，回收的过程没有对象的移动。使其相对
其他有对象移动步骤的回收算法，仍然是是效率最好的，但是需要解决内存碎片的问题。