前言
本节首要环绕下面三个方向进行知识点的解说，带你从架构师角度认识内存溢出
虚拟机中目标的创建过程
当 JVM 遇到一条字节码 new 指令的时分，它首先会进行：
检查加载
检查对应的类有没有加载进来，假如没有加载进来，则要从头进行类加载，直到类加载成功，成功之后继续进行检查加载，详细检查什么呢？
Object obj = new Object();
例如上面这段代码，它会检查经过设置的 new 的参数（new Object）是否能在办法区的常量池中找到这个类的符号引证，
什么是类的符号引证？
用一组符号来描绘你所引证的目标，例如 NBA 球员 James，这个 James 便是一个符号引证，假定 James 不来中国，那么你是看不到他的，你只看到了这个符号；那么关于类来说，这个类的前面加了 com.american.James，一起它要检查这个 James 类有没有被加载过；
分配内存
检查加载成功之后，就要开始分配内存，那么 JVM 是怎么区分内存的呢？目标请求内存空间流程是怎样的呢？
区分内存有两种办法，一种是指针磕碰、一种是空闲列表
指针磕碰
假定咱们的堆内存比较规整，赤色代表已经分配了内存，白色代表未分配的内存，这个堆内存比较规整，咱们能够运用一个指针指向堆内存中的最终一个目标的偏移量，当咱们给一个目标请求内存空间的时分，这个指针就会依据这个目标的 size 挪动到指定的方位来放下创建的这个目标，这个就叫做指针磕碰（移动一个目标巨细的间隔）；别的这种指针磕碰只能在堆空间比较规整的情况下，可是经过废物收回之后，就会变成零散的，不规整的，那么指针磕碰在这种情况下就不适宜了，这种时分，JVM 就会保护一个空闲列表；
空闲列表
JVM 用空闲列表来符号对应的方位是否有目标存在，在分配方位的时分，假定目标需求一个方位巨细，就分配到 1 的方位，假如需求三个巨细，就分配到 3-5 这个方位；
上面两种区分办法都是由于：在 JVM 中目标要占有的内存必定要是连续的；
JVM 用哪种办法来区分，取决于堆的规整程度；堆空间的规整度 又是由废物收回器决议的，废物收回器是否带有整理功用；
不管运用 指针磕碰 仍是 空闲列表，JVM 为了提高功率，同样运用了多线程，那么就会带来多线程安全问题，那么 JVM 是怎么解决并发安全的问题呢？
CAS加失利重试
A B 两个分配内存的时分，都会去抢同一块内存，会进行查询操作，查询下这块空间是不是空的，A B 两个线程拿到的都是空的，就会进行 CAS 操作，由于 CAS 操作是由 CPU 确保线程的履行次序，假定 A 比 B 先履行，当 A 进行 CAS 操作的时分，判别这块空间是空的，就进行交流占有这块内存，当 B 进行 CAS 操作的时分，比较发现这块区域不空了，就会进行重试，直到找到一块为空的区域，然后进行交流操作；
CAS原理能够检查之前的解说：怎么应对Android面试官->CAS基本原理
本地线程分配缓冲
CAS 比较而且交流，比较和交流，必定消耗功能，所以 JVM 供给了第二种办法：本地线程分配缓冲（Thread Local Allocation Buffer）简称 TLAB；
本地线程分配缓冲类似 ThreadLocal，堆中的 eden 预先给每个线程区分单独的一块区域，当线程履行的时分，直接分配，就不需求采取安全措施，这便是本地线程分配缓冲，可是 TLAB 比较小，只占用 eden 区的 1%；
什么时分 CAS，什么时分分配缓冲？
分配缓冲默认开启，假如要禁用，能够运用下面的装备选项
-XX:-UseTLAB
内存空间初始化
内存空间的初始化不是结构办法，而是在内存分配之后，区分了一块区域，可是这块区域是空的，需求把里边的一些数据设置为 **零值，**这一步确保了目标在分配完内存后，在代码里边不需求赋值就能够直接运用，程序越早运用目标，它的功率就越高，这便是内存空间初始化；
什么是零值？
比方 int 类型，那么它的零值便是 0，boolean 类型，它的零值便是 false，
设置
目标归于哪个实例，需求设置一下，以及设置目标头；
目标的初始化
调用结构办法进行目标的初始化；
以上过程，针对的是 一般的目标（也便是咱们编写的程序），由于 Java 中万物介目标；
虚拟机中目标的布局
HotSpot 中目标能够分为三块：目标头、实际数据、对齐补充
目标头
Mark Word（存储目标本身的运转时数据）
哈希码、GC分代年纪、锁状态符号、线程持有的锁、倾向线程ID、倾向时间戳；
类型指针
指向类目标信息的指针；
Person p = new Person();
p 是一个引证目标，存在栈中（java虚拟机栈中的栈桢），new Person() 存在于堆中， 假定有一个 A 类，A 类中有一个 Person 目标，这个目标存储于堆区，那么它就会指向办法区的这个 A类（办法区存储类的描绘信息），指向的过程便是这个 Class Pointer；
若为目标数组，还应有记录数组长度的数据
lenght 数据长度，只针对数组目标；
实例数据
包括目标一切成员变量，依据变量类型决议巨细；
对齐填充
为了让目标的巨细为8字节的整数倍；
为什么要对齐填充？
由于在 HotSpot 中，它对管理的目标的巨细是有要求的，有必要是 8 字节的整数，可是 目标头和实例数据是没有办法控制的，假定目标头 + 实例数据刚好 38 字节，那么对齐填充就会填充 2 个字节，假如目标头和实例数据加起来刚好是 8 的整数倍，那么这个对齐填充就不需求了；填充的话随便用一些值填充就能够了；
虚拟机中目标的拜访定位
一切的虚拟机中（包括 HosSpot）目标的拜访定位都有两种办法：运用句柄、直接指针
运用句柄
什么是句柄？
句柄便是在堆空间划一块区域，叫作句柄池，句柄池中寄存的是什么呢？目标的拜访经过 reference ，这个 reference 中就不会寄存目标的地址了，而是寄存一个叫作目标实例的指针，句柄其实便是做了一次中转，经过句柄池找到真实的目标实例数据，这样做的好处便是：假如目标进行了移动，句柄池不需求修正，仍是能够经过句柄池找到对应的目标实例；
例如：句柄池中寄存的是 Kobe 的目标实例指针，实例池中寄存的是 Kobe 的实例，可是 Kobe 离开之后，句柄池的这个指针不需求修正，当有一个新的 Kobe 实例被替换的时分，仍是能够经过这个指针找到对应的 Kobe 实例；
可是这样做的害处是需求经过 Auth 查找；经过这个句柄池再映射一次，会有一次额外的指针定位开销，尽管这个开销比较小，可是 JVM 中目标的创建是比较疯狂的，这块会存在一个积少成多，那么虚拟机又供给了别的一种办法：直接指针；
直接指针
Person p = new Person();
在 HotSpot 中 运用的便是直接指针，这个 p 便是一个引证，这个引证就会指向真实的地址；这样做尽管带来了功率的提高，可是假如目标一直被移来移去，目标在物理区 移来移去，那么这个 reference 就会进行改变；
怎么判别目标的存活
在 JVM 中目标是能够被收回的，首先目标是在堆中进行分配的，假如堆空间满了，就会触发废物收回，可是在进行废物收回之前咱们要确认哪些目标是存活的；怎么判别呢？大部分都是选用的下面这两种办法
引证计数法
用一个计数器来统计目标被引证，目标被引证了，计数器就+1，假如这个引证失效了，就 -1，假如等于 0 阐明这个目标不被引证了；
这里会存在一个问题：目标的彼此引证；
上图中的两个目标就存在彼此引证，可是又跟运转办法里边的不相关，外部没有可用的地方与它进行连接，它其实也是死的；
可达性剖析（根可达）
JVM 中用的便是可达性剖析法，本质上是依据一条链路来追寻的，这条链路以 GC Roots 的变量（静态变量、线程栈变量、常量池变量、JNI指针变量）或许目标（class、Exception、OOM、类加载器、加锁 synchronized 目标、JMXBean、临时性）为根节点，构成引证链路的则为存活目标，没有被 GC Roots 直接引证或许直接引证的都是能够收回的目标；
经过下面的代码能够验证 HotSpot 运用的是可达性剖析法
// -XX:+PrintGC
public class ReliabilityAnalysisTest {
public Object instance = null;
// 辅助效果，占有内存，用来可达性剖析
private byte[] bigSize = new byte[10 * 1024 * 1024];
public static void main(String[] args) {
ReliabilityAnalysisTest test = new ReliabilityAnalysisTest();
ReliabilityAnalysisTest test1 = new ReliabilityAnalysisTest();
// 彼此引证
test.instance = test1;
test1.instance = test;
// 免除引证
test.instance = null;
test1.instance = null;
// 收回内存
System.gc();
}
}
VM参数加上注释的装备信息-XX:+PrintGC 运转之后能够看到，内存进行了收回，阐明引证计数法的办法在 HotSpot 中没有被运用；假如是可达性剖析的话，这两个目标必然不会被收回；
可达性剖析算法之后，没有引证链，可是相互引证的目标，也不是立马就会被收回，它们其实处于缓刑状态，仍是能够被抢救的，可是这个抢救是需求开发者经过代码完成的，可是 finalize 只能履行一次，能够看下面的代码示例；
public class FinalizeTest {
public static FinalizeTest instance;
public void isAlive() {
System.out.println("is Alive");
}
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("finalize execute");
FinalizeTest.instance = this;
}
public static void main(String[] args) throws InterruptedException {
instance = new FinalizeTest();
// 第一次 GC
instance = null;
System.gc();
Thread.sleep(1000); // 等待 finalize 办法履行
if (instance != null) {
System.out.println("第一次GC后，目标实例不为空");
instance.isAlive();
} else {
System.out.println("第一次GC后，目标实例为空");
}
// 第2次 GC
instance = null;
System.gc();
Thread.sleep(1000); // 等待 finalize 办法履行
if (instance != null) {
System.out.println("第2次GC后，目标实例不为空");
instance.isAlive();
} else {
System.out.println("第2次GC后，目标实例为空");
}
}
}
能够看到第一次 GC 后，履行了 finalize 办法，进行了解救，可是第2次 GC 之后，就被收回了；
这里为什么要加 sleep，是由于 finalize 的线程优先级十分低，假如去掉 sleep 则解救不成功；
能够看到第一次 GC 之后就被收回了；
所以 finalize 尽量不要运用，这个办法太不可靠了；
JVM中的引证类型
强引证
Object obj = new Object();
这种便是强引证，只需 GC Roots 还在，那么强引证的就不会被收回；
软引证
内存不足，将要产生OOM的时分，会被收回；能够检查下面的代码示例
// -Xms20M -Xmx20
Mpublic class SoftReferencesTest {
static class User {
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
}
public static void main(String[] args) {
User user = new User("张三", 18);
SoftReference<User> softReference = new SoftReference<>(user);
System.out.println("GC 前读取：" + softReference.get());
user = null; // 置空，确保只要软引证指向该目标
System.gc(); // 手动触发GC
System.out.println("GC 后读取：" + softReference.get());
// 结构内存溢出
List<byte[]> list = new ArrayList<>();
try {
for (int i = 0; i < 10000; i++) {
list.add(new byte[1024 * 1024]);
}
} catch (Throwable e) {
System.out.println("内存溢出：" + softReference.get());
}
}
}
能够看到，当产生内存溢出的时分，被收回掉了，这个时分咱们获取弱引证中的数据是拿不到的；
弱引证
GC 扫描到了就会收回；
public class WeakReferencesTest {
static class User {
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
}
public static void main(String[] args) {
User user = new User("张三", 18);
WeakReference<User> weakReference = new WeakReference(user);
System.out.println("GC 前读取：" + weakReference.get());
user = null; // 置空，确保只要软引证指向该目标
System.gc(); // 手动触发GC
System.out.println("GC 后读取：" + weakReference.get());
}
}
能够看到 GC 的时分，就被收回掉了；
虚引证
随时都会被收回，不知道什么时分就被收回了；首要用来监控废物收回器是否正常工作，一般业务开发中用不到；
目标请求内存空间流程
目标的分配准则
- 目标优先在Eden分配；
- 空间分配担保；
- 大目标直接进入老时代；
- 长时间存活的目标进入老时代；
- 动态目标年纪判定；
目标分配时的优化技能
当咱们 new 一个目标的时分，JVM 的第一个优化便是：是否栈上分配？
一般咱们总是说：几乎一切目标都是堆中分配，但不是 100%，它也能够在栈上分配，而且在栈上分配的目标，就不需求废物收回，这也是为什么办法要在栈中履行的原因，功率高，栈的内存是跟从线程的，线程履行完了，这个栈也就完毕了；
假如想在栈上分配目标，HotSpot 需求一项技能：逃逸剖析技能；
逃逸剖析：判别办法的目标有没有逃逸，便是剖析这个目标的效果域
- 是不是能够逃逸出办法体；
- 是不是能够逃逸出其他线程；
能够看下面代码示例
// -XX:+PrintGC
// -XX:-DoEscapeAnalysis
public class EscapedAnalysisTest {
public static void main(String[] args) throws InterruptedException {
long start = System.currentTimeMillis();
for (int i = 0; i < 6_000_000_0; i++) {
allocate();
}
System.out.println("Escaped Analysis: " + (System.currentTimeMillis() - start));
Thread.sleep(60_000);
}
static void allocate() {
Person person = new Person(1000L, 2000L);
}
static class Person {
private long age;
private long height;
public Person(long age, long height) {
this.age = age;
this.height = height;
}
}
}
Person person = new Person(1000L, 2000L);
person 就会被分配到栈上，它满意 不会逃逸出办法体（办法外没有调用），也不会逃逸出其他线程（只要一个main线程）；
-XX:-DoEscapeAnalysis // 关闭逃逸剖析
假如不想运用栈上分配（不做逃逸剖析）的运转结果，能够加上上面的装备信息；履行结果如下
能够看到触发了 GC；
JVM的第二个优化便是：堆中本地线程分配缓冲，
上面已经介绍了；
目标优先在 Eden 区分配
假如不支持 本地线程分配缓冲，会判别是不是大目标，假如不是大目标，则在 Eden 区分配，满意了目标优先在 Eden 区分配的准则之一，假如是大目标，则直接分配到老时代（满意了大目标直接进入老时代准则之一）
大目标：一般是很长很长的字符串、数组；
假如咱们经过参数 -Xms30M -Xmx30M 来设置咱们的JVM 堆区为 30M，那么老时代就会分配20M，Eden区分配 8M，From区分配 1M， To区分配 1M；
也便是说重生代只占堆内存的三分之一，所以说大目标放到老时代能够防止废物收回；
JVM 能够经过参数设置是否为大目标，-XX:+PretenureSizeThresold10M，大于等于10M的目标则以为是大目标，直接分配到老时代；
Eden 上分配之后还会遵从一个准则：长时间存活的目标进入老时代；
当触发废物收回的时分，由于 Eden 区只寄存重生目标，Eden 中一切存活的目标都将被移动到 From 区，目标的目标头中的 age（Mark Word 区域的 GC分代年纪） 就会 +1，然后 Eden 被清空，Eden 被清空，当再次充溢的时分，一切存活的目标和 From survivor 中一切存活的目标都被移动到 To survivor，然后 Eden 和 From survivor 被清空，这个时分 To 中的目标的目标头中的 age 会再次 +1 （=2），当再次充溢触发废物收回的时分，会把存活的目标和 Tosurvivor中一切存活的目标都被移动到 Fromsurvivor，然后 Eden 和 To survivor 被清空，这个时分 From 中的目标的目标头中的 age 会再次 +1（=3），From 和 To 循环往复，当 age = 15 的时分，会被移动到老时代（满意了长时间存活目标进入老时代准则之一），这种循环往复选用的便是 仿制收回 算法；
JVM 为什么不把 Eden、From、To 合并成两个，只保存 From和 To呢？
这是由于仿制收回算法要浪费一半的空间，为什么要浪费一半呢？如果仿制曩昔的满是存活目标，比方从 From 仿制到 To 的都是存活目标，可是 To 中没有满足的空间包容下这些目标了；所以往往仿制算法的空间都是一分为二，导致内存利用率只要50%；Oracle 和 Sun 公司做过大数据统计，90% 的目标在被废物收回的时分都能收回掉，只剩 10% 的存活目标，这 10% 的存活目标放入 From 区，那么就需求一个对等的 To 区，所以选用这样的一种办法的废物收回，那么浪费的只要 10% 的空间，空间利用率能够到达 90%；所以就没必要选用规范的仿制收回，把堆区一分为二，而是分红三份区域，第一次废物收回的时分，移动到 From 区，后续选用规范的仿制收回算法，从 From 仿制到 To 区；
JVM 的仿制收回算法为什么是 15 次，才会移动到老时代，能够修正这个值吗？
JDK 供给的 markOop.hpp（也便是 Mark Word） 文件中有提及到：
不管是 32 位的虚拟机仍是 64 位的虚拟机，这个 age 都是寄存的 4 位，从二进制来看寄存的最大值便是 1111，按照十六进制转化，便是 15，所以说仿制收回 age 的最大次数默认是 15 次；
JVM 也供给修正参数，能够修正这个值：
-XX:MaxTenuringThresold = 10 // 就能够修正这个值；
进入老时代的目标，age 就不会在被符号 +1；
废物收回的两个概念
在进行废物收回的时分，它其实是有两个概念的，在进行分代的时分，它能够选用两种 GC，废物收回器收回重生代称之为 Minor GC，收回老时代称之为 Major GC；
空间分配担保
经过堆中的目标分配准则，目标在分配的时分有 Eden 区 进入 From 区或许 To 区，最终进入 Tenured 区，大部分情况下老时代的目标都是由重生代晋级来的，可是假定老时代就只剩余 1M 的空间了，然后还有从 From 或许 To 区做一个目标的晋级，或许经过大目标分配，可是在进行目标晋级或许大目标分配，不能确保必定会有满足的空间来寄存，所以在每一次晋级或许大目标分配的时分，本身要做一次Major GC，这种办法比较安全，可是 JVM 以为这种很影响功率，所以 JVM 就提出了一个概念叫作：空间分配担保，这个担保由 JVM 来担保，放心分配，假如的确不够了，再进行一次Major GC，而不必每次晋级都要触发，这就满意了目标分配空间分配担保准则之一；
动态年纪判别
为了优化 From 区和 To 区，由于这两个区域本身也不大，假定 From 区中有三个目标，这三个目标的年纪加起来仅仅是5，可是这三个目标占有了 From 区的一半，那么这个时分它会走一个动态年纪判别，并不必定非要到达15，就会让这个几个目标提前晋级到老时代，这些目标就不需求等到15之后再进入老时代；
整体请求内存空间流程
-
先去 eden 区看看是否有满足的空间；
-
有，直接分配
-
无，JVM 开始收回废物目标，收回完成之后，判别 eden 是否有满足空间；
-
有，直接分配；
-
无，s 区域是否有满足空间；
-
有，eden 区的存活目标移动到 s 区，新目标就能够在 eden 请求成功；
-
无，启用担保机制，old 区是否满足空间；
-
有，将s区的存活目标移动到 old 区，eden将存活目标放到s区，请求成功；
-
无，JVM 触发 full gc，gc 之后检查 old 区是否有满足空间；
-
有，将s区的存活目标移动到old区，eden将存活目标放到s区，请求成功；
-
无，OOM；
简历润色
简历上可写：深度了解JVM内存分配原理，能基于分配原理进行深度优化；
下一章预告
带你玩转废物收回；
欢迎三连
来都来了，点个赞，点个重视吧~~~
