JVM基础知识

内存模型
1.分布图:

2.存储内容:
堆
1.存储对象实例以及数组,绝大多数新建的对象（新建的大对象会直接放到老年代）会在年轻代
2.但绝大多数存活下来的对象在老年代

程序计数器
1.记录虚拟机字节码指令的地址（当前指令的地址）
2.（时间片用完）当线程切换时记录当前线程执行到哪个位置，下次抢到CPU时，直接从此处开始执行
3.如果线程执行的是本地方法时，程序计数器的值为NULL
4.程序计数器是唯一一块不会发生OOM的内存区域

本地方法栈
1.只为Native方法服务
2.每个方法在执行的同时都会创建一个栈帧（Stack Frame）
3.用于存储局部变量表、操作数栈、动态链接、方法出口、对象的引用、私有数据等信息
4.栈帧随着方法的创建而创建，也随着方法的结束而销毁，方法正常执行结束或抛出异常都表示着方法执行结束
通用:
1.栈对应线程，栈帧对应方法
2.在活动线程中， 只有位于栈顶的帧才是有效的， 称为当前栈帧
3.正在执行的方法称为当前方法，在执行引擎运行时， 所有指令都只能针对当前栈帧进行操作

JVM虚拟机栈
1.只为Java方法服务
2.每个方法在执行的同时都会创建一个栈帧（Stack Frame）
3.用于存储局部变量表、操作数栈、动态链接、方法出口、对象的引用、私有数据等信息
4.栈帧随着方法的创建而创建，也随着方法的结束而销毁，方法正常执行结束或抛出异常都表示着方法执行结束

方法区
1.方法区作为JVM规定的一种规范，在JDK1.7之前HotSpot对其进行了实现，体现为永久代
2.JDK1.8之后进行了改版，将原来的永久代删除，重新根据方法区的规范实现了新的，体现为元空间
3.类的元数据放入 native memory, 字符串池和类的静态变量放入 java 堆中，这样可以加载多少类的元数据就不再由MaxPermSize 控制, 而由系统的实际可用空间来控制
4.为了便于理解，请看图

3.相互关系

4.创建对象，内存分配

5.对象个体内存分配

Markword分布细节

6.常用调优参数

对象年龄：
-XX:MaxTenuingThreshold : 可以设置对象从年轻代到老年代的年龄阈值

偏向锁:
启用参数: 
-XX:+UseBiasedLocking
关闭延迟: 
-XX:BiasedLockingStartupDelay=0 
禁用参数: 
-XX:-UseBiasedLocking

垃圾回收与算法
主体梳理

1.对象引用
无论用什么算法去判断对象是否可回收，都和对象的引用息息相关

强引用

程序代码中，类似“Object obj = new Object()”这一类引用，均为强引用
只要存在强引用，垃圾收集器就不会收集该对象

软引用

用于描述一些还存在用处，但非必须的对象引用
在即将内存溢出异常之前，收集器会对这一类对象进行一次回收
如果该次回收仍旧内存不足，则会抛出内存溢出异常

弱引用

用于描述非必须对象，但性质要比软引用弱上一些
该类对象只能存活到下一次GC之前，下一次GC来临时，无论内存是否足够该类引用的对象均会被回收

虚引用

作为一种标记引用，标记着对象什么时候会被回收，必须配合一个引用队列一期使用，不会决定对象的生命周期
对象在执行finalize函数后会被放入引用队列，后可以通过判断队列中是否存在该对象来判断它是否已被回收

2.确认垃圾（实例对象）
引用计数法
1.由对象自身去维护一个计数器，当该对象被关联引用时，计数器+1，引用去掉时计数器-1，当计数器的值为0时，代表该对象不被任何地方引用，可以被回收（并不代表一定会被回收）
2.该方法无法解决循环引用问题

public class Main {
    public static void main(String[] args) {
        GCObject object1 = new GCObject();
        GCObject object2 = new GCObject();
 
        object1.object = object2;
        object2.object = object1;
 
        object1 = null;
        object2 = null;
    }
}

class GCObject{
    public Object object = null;
}

分析：
1.object1和object2先是相互引用，自身的计数器均为1
2.但随后将两个对象置空，但是二者计数器均还是为1，就会造成JVM永远无法回收给这两个对象分配的内存空间

可达性分析
1.为了解决引用计数法存在的循环问题，Java使用了可达性分析方法
2.本质是以一系列的GC ROOT对象为根节点，向下搜索，如果存在引用链路，那么表示该对象可达，则不可以回收，反之则不可达
3.GC ROOT对象：栈中引用对象，类的静态变量引用对象，本地方法栈JNI引用对象，final的常量值引用的对象
4.当对象第1次被标记为不可达时，并不代表该对象可以被回收，只有第2次被标记为不可达时，才表示该对象可被回收

3.确认垃圾（类）
该类所有的实例都已经被回收，也就是 Java 堆中不存在该类的任何实例。
加载该类的 ClassLoader 已经被回收。
该类对应的 java.lang.Class 对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。

4.收集算法

标记-清除算法（Mark-Sweep）
标记-清除算法采用从根集合（GC Roots）进行扫描，对存活的对象进行标记，标记完毕后，再扫描整个空间中未被标记的对象，进行回收，如下图所示。标记-清除算法不需要进行对象的移动，只需对不存活的对象进行处理，在存活对象比较多的情况下极为高效，但由于标记-清除算法直接回收不存活的对象，因此会造成内存碎片。

复制算法(Copying)
为了解决Mark-Sweep算法的缺陷，Copying算法就被提了出来。它将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后再把已使用的内存空间一次清理掉，这样一来就不容易出现内存碎片的问题。
这种算法虽然实现简单，运行高效且不容易产生内存碎片，但是却对内存空间的使用做出了高昂的代价，因为能够使用的内存缩减到原来的一半。
很显然，Copying算法的效率跟存活对象的数目多少有很大的关系，如果存活对象很多，那么Copying算法的效率将会大大降低。
复制算法的提出是为了克服句柄的开销和解决内存碎片的问题。它开始时把堆分成 一个对象 面和多个空闲面， 程序从对象面为对象分配空间，当对象满了，基于copying算法的垃圾 收集就从根集合（GC Roots）中扫描活动对象，并将每个 活动对象复制到空闲面(使得活动对象所占的内存之间没有空闲洞)，这样空闲面变成了对象面，原来的对象面变成了空闲面，程序会在新的对象面中分配内存。

标记-整理算法(Mark-compact)
为了解决Copying算法的缺陷，充分利用内存空间，提出了Mark-Compact算法。该算法标记阶段和Mark-Sweep一样，但是在完成标记之后，它不是直接清理可回收对象，而是将存活对象都向一端移动(美团面试题目，记住是完成标记之后，先不清理，先移动再清理回收对象)，然后清理掉端边界以外的内存(美团问过)
标记-整理算法采用标记-清除算法一样的方式进行对象的标记，但在清除时不同，在回收不存活的对象占用的空间后，会将所有的存活对象往左端空闲空间移动，并更新对应的指针。标记-整理算法是在标记-清除算法的基础上，又进行了对象的移动，因此成本更高，但是却解决了内存碎片的问题。具体流程见下图：

分代收集算法 Generational Collection（分代收集）算法
分代收集算法是目前大部分JVM的垃圾收集器采用的算法。它的核心思想是根据对象存活的生命周期将内存划分为若干个不同的区域。一般情况下将堆区划分为老年代（Tenured Generation）和新生代（Young Generation），在堆区之外还有一个代就是永久代（Permanet Generation）。老年代的特点是每次垃圾收集时只有少量对象需要被回收，而新生代的特点是每次垃圾回收时都有大量的对象需要被回收，那么就可以根据不同代的特点采取最适合的收集算法。
目前大部分垃圾收集器对于新生代都采取Copying算法，因为新生代中每次垃圾回收都要回收大部分对象，也就是说需要复制的操作次数较少，但是实际中并不是按照1：1的比例来划分新生代的空间的，一般来说是将新生代划分为一块较大的Eden空间和两块较小的Survivor空间（一般为8:1:1），每次使用Eden空间和其中的一块Survivor空间，当进行回收时，将Eden和Survivor中还存活的对象复制到另一块Survivor空间中，然后清理掉Eden和刚才使用过的Survivor空间。
而由于老年代的特点是每次回收都只回收少量对象，一般使用的是Mark-Compact算法。

年轻代（Young Generation）的回收算法 (回收主要以Copying为主)
a) 所有新生成的对象首先都是放在年轻代的。年轻代的目标就是尽可能快速的收集掉那些生命周期短的对象。
b) 新生代内存按照8:1:1的比例分为一个eden区和两个survivor(survivor0,survivor1)区。一个Eden区，两个 Survivor区(一般而言)。大部分对象在Eden区中生成。回收时先将eden区存活对象复制到一个survivor0区，然后清空eden区，当这个survivor0区也存放满了时，则将eden区和survivor0区存活对象复制到另一个survivor1区，然后清空eden和这个survivor0区，此时survivor0区是空的，然后将survivor0区和survivor1区交换，即保持survivor1区为空(美团面试，问的太细，为啥保持survivor1为空，答案：为了让eden和survivor0 交换存活对象)， 如此往复。当Eden没有足够空间的时候就会 触发jvm发起一次Minor GC
c) 当survivor1区不足以存放 eden和survivor0的存活对象时，就将存活对象直接存放到老年代。若是老年代也满了就会触发一次Full GC(Major GC)，也就是新生代、老年代都进行回收。
d) 新生代发生的GC也叫做Minor GC，MinorGC发生频率比较高(不一定等Eden区满了才触发)。
年老代（Old Generation）的回收算法（回收主要以Mark-Compact为主）
a) 在年轻代中经历了N次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。
b) 内存比新生代也大很多(大概比例是1:2)，当老年代内存满时触发Major GC即Full GC，Full GC发生频率比较低，老年代对象存活时间比较长，存活率标记高。
持久代（Permanent Generation）(也就是方法区)的回收算法
方法区主要回收的内容有：废弃常量和无用的类。对于废弃常量也可通过引用的可达性来判断，但是对于无用的类则需要同时满足下面3个条件：
● 该类所有的实例都已经被回收，也就是Java堆中不存在该类的任何实例；
● 加载该类的ClassLoader已经被回收；
● 该类对应的java.lang.Class对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。

垃圾收集器
CMS收集器
全称：CMS(Concurrent Mark Sweep)，并发标记清除

收集步骤：
1.初始标记：
从GC Roots出发，找到第一个可关联的对象，速度快，此时用户线程停止，即产生停顿（不可预测）

2.并发标记：
从初始标记关联的第一个对象出发，向下进行追溯，此时用户线程不会停止，不产生停顿，但较耗时，标记所有可达对象

3.重新标记：
由于并发标记阶段，用户线程是没有停止的，这个过程中，有可能会改变对象的引用，而导致标记不完全或不正确，因此需要再次重新标记
该阶段需要停止用户线程，会产生卡顿（不可预测），扫描脏卡表，将跨代引用的卡表也记录起来，GC的时候就不会收集这一类脏卡表的对象

4.并发清除：
将没有引用链，即不可达的对象进行清除
G1收集器
基于“标记-整理”算法设计，实现高吞吐，低停顿且停顿时间可预见的特性！
步骤：
1.初始标记：同上，停顿很小
2.并发标记：同上，无停顿
3.最终标记：为了修正在并发标记期间因用户程序继续运作而导致标记产生变动的那一部分标记记录，虚拟机将这段时间对象变化记录在线程的 Remembered Set Logs 里面，最终标记阶段需要把 Remembered Set Logs 的数据合并到 Remembered Set ，这阶段需要停顿线程，但是可并行执行
4.筛选回收：首先对各个 Region 中的回收价值和成本进行排序，根据用户所期望的 GC 停顿时间来制定回收计划。此阶段其实也可以做到与用户程序一起并发执行，但是因为只回收一部分 Region，时间是用户可控制的，而且停顿用户线程将大幅度提高收集效率

特性:
空间整合: 整体来看是基于“标记 - 整理”算法实现的收集器，从局部(两个 Region 之间)上来看是基于“复制”算法实现的，这意味着运行期间不会产生内存空间碎片。
可预测的停顿: 能让使用者明确指定在一个长度为 M 毫秒的时间片段内，消耗在 GC 上的时间不得超过 N 毫秒
CMS和G1的差别
物理内存：
①CMS在物理内存上来说，新生代和老年代是严格按照物理隔离来进行实现的
②G1将堆分成若干个大小相等的独立区域（Region），新生代和老年代不再物理隔离，只是存在逻辑上的隔离。
停顿时间：
CMS和G1都实现了低停顿，但CMS的停顿时间不可预见，而G1的停顿时间可以预见！（收集器可以根据用户设置的停顿时间去寻找合适的Region，在可预见的时间范围内进行回收）
吞吐量:
①CMS的吞吐量受CPU的影响
默认回收线程为：（CPU数+3）/ 4
由该公式得出：
当CPU数量4个以上时，并发回收时，垃圾收集线程最多占用不超过25%CPU资源；但当CPU数量小于4时，并发回收时，垃圾收集线程占用就是大于75%，CPU在高速运算时，还要分出一半多的算力去进行垃圾回收，很大程度降低了用户程序的执行速度，降低吞吐量。
②G1的吞吐量则不太会受CPU资源的影响，基本保持着高吞吐
收集算法：
①CMS是基于标记清楚算法实现
②G1是基于标记整理算法实现，局部可以看作复制算法
浮动垃圾：
①CMS因为并发清除阶段用户线程仍在运行，此时产生的垃圾只能等下一次垃圾回收。也是因此，在进行并发清除的时候，需要预留一些空间给用户程序，如果在并发清除阶段内存无法满足用户线程产生的垃圾，就会报出Concurrent Mode Failure
②G1基于则不会
空间碎片：
①CMS基于“标记-清除”算法实现，产生空间碎片
②G1则基于，“标记-整理”算法实现，不会产生空间碎片

图是来自网络或公众号，如有侵权请联系删除