垃圾回收篇

1. 概述

垃圾收集，不是Java语言的伴生产物。早在1960年，第一门开始使用内存动态分配和垃圾收集技术的Lissp语言诞生。
垃圾收集机制是Java的招牌能力,极大地提高了开发效率。如今，垃圾收集几乎称为现代语言的标配，即使经过如此长时间的发展，Java的垃圾收集机制仍然在不断的演进中，不同大小的设备、不同特征的应用场景。

垃圾是指在运行程序中没有任何指针指向的对象，这个对象就是需要被回收的垃圾。如果不及时对内存中的垃圾进行清理，那么，这些垃圾对象所占的内存空间会一致保留到应用程序结束，被保留的空间无法被其他对象使用。甚至可能导致内存溢出。

对于高级语言来说，一个基本认知是如果不进行垃圾回收，内存迟早都会被消耗完，因为不断地分配内存空间而不进行回收，就好像不停地生产生活垃圾而从来不打扫一样。除了释放没用的对象，垃圾回收也可以清除内存里的记录碎片。碎片整理将所占用的堆内存移到堆的一端，以便 JVM 将整理出的内存分配给新的对象。随着应用程序所应付的业务越来越庞大、复杂，用户越来越多，没有GC就不能保证应用程序的正常进行。而经常造成STW的GC又跟不上实际的需求，所以才会不断地尝试对GC进行优化。

另一方面对于Java开发人员而言，自动内存管理就像是一个黑匣子，如果过度依赖于“自动”，那么这将会是一场灾难，最严重的就会弱化Java开发人员在程序出现内存溢出时定位问题和解决问题的能力。此时，了解JVM的自动内存分配和内存回收原理就显得非常重要，只有在真正了解JVM是如何管理内存后，我们才能够在遇见OutOfMemoryError时，快速地根据错误异常日志定位问题和解决问题。当需要排查各种内存溢出、内存泄漏问题时，当垃圾收集成为系统达到更高并发量的瓶颈时，我们就必须对这些“自动化”的技术实施必要的监控和调节。

垃圾回收器可以对年轻代回收，也可以对老年代回收。甚至是全堆和方法区的回收。其中Java堆事垃圾收集器的重点工作。从次数上讲：频繁收集Young区，较少收集Old区，基本不动Perm区(或元空间)

2. 垃圾回收算法

2.1 垃圾判别阶段算法

在堆里存放着几乎所有的java对象实例，在GC执行垃圾回收之前，首先需要区分出内存中哪些是存活对象，哪些是已经死亡的对象。只有被标记为已经死亡的对象，GC才会在执行垃圾回收时，释放掉其所占用的内存空间，因此这个过程我们可以称为垃圾标记阶段。当一个对象已经不在被任何的存活对象继续引用时，就可以宣判为已经死亡。

2.1.1 引用计数算法

引用计数算法(Reference Counting)比较简单，对每个对象保存一个整型的引用计数器属性。用于记录对象被引用的情况。

对于一个对象A,只要有任何一个对象引用了A，则A的引用计数器就加1，当引用失效时，引用计数器就减1。只要对象A的引用计数器的值为0，即表示对象A不可能再被引用，可以进行回收。

此算法的优点是实现简单，垃圾对象便于辨识；判定效率高，回收没有延迟。缺点是：它需要单独的字段存储计数器，这样的做法增加了存储空间的开销；每次赋值都需要更新计数器，伴随着加法和减法操作，这增加了时间开销；引用计数器有一个严重的问题，即无法处理循环引用的情况。这是一条致命缺陷，导致在Java 的垃圾回收器中没有使用这类算法。

/**
 * -XX:+PrintGCDetails
 * @author shkstart
 * @create 2020 下午 2:38
 */
public class RefCountGC {
    //这个成员属性唯一的作用就是占用一点内存
    private byte[] bigSize = new byte[4 * 1024 * 1024];
    Object reference = null;
    public static void main(String[] args) {
        RefCountGC obj1 = new RefCountGC();
        RefCountGC obj2 = new RefCountGC();

        obj1.reference = obj2;
        obj2.reference = obj1;

        obj1 = null;
        obj2 = null;
        //显式的执行垃圾回收行为
        //这里发生GC，obj1和obj2能否被回收？
        System.gc();
    }
}

如果一下小心直接把Obj1-reference 和 Obj2-reference 置 null。则在 Java 堆当中的两块内存依然保持着互相引用，无法回收。

引用计数算法，是很多语言的资源回收选择，例如因人工智能而更加火热的Python，它更是同时支持引用计数和垃圾收集机制。业界有大规模实践中仅保留引用计数机制，以提高吞吐量的尝试。但是Java并没有选择引用计数，是因为其存在一个基本的难题，也就是很难处理循环引用关系。Python是通过手动再合适的时机，解除引用关系。使用弱引用weakref， weakref是Python提供的标准库，旨在解决循环引用。

2.1.2 可达性分析算法

相对于引用计数算法而言，可达性分析算法不仅同样具备实现简单和执行高效等特点，更重要的是该算法可以有效地解决在引用计数算法中循环引用的问题，防止内存泄漏的发生。可达性分析就是Java、C#选择的。这种类型的垃圾收集通常也叫作追踪性垃圾收集（Tracing Garbage Collection）。

其原理简单来说，就是将对象及其引用关系看作一个图，选定活动的对象作为 GC Roots，然后跟踪引用链条，如果一个对象和GC Roots之间不可达，也就是不存在引用链条，那么即可认为是可回收对象。

基本思路:

1. 可达性分析算法是以根对象集合(GC Roots)为起始点，按照从上至下的方式搜索被根对象集合所连接的目标对象是否可达。
2. 使用可达性分析算法后，内存中的存活对象都会被根对象集合直接或间接连接着，搜索所走过的路径称为引用链(Reference Chain)
3. 如果目标对象没有任何引用链相连，则是不可达的，就意味着该对象己经死亡，可以标记为垃圾对象。
4. 在可达性分析算法中，只有能够被根对象集合直接或者间接连接的对象才是存活对象。
   
   这种算法实现简单，执行高效 ，有效的解决循环引用的问题，防止内存泄漏。

在Java语言中，GC Roots包括一下几类元素:

1. 虚拟机栈中引用的对象,比如各个线程被调用的方法中使用到的参数、局部变量等
2. 本地方法栈内JNI(通常说的本地方法)引用对象
3. 类静态属性引用的对象，比如Java类的引用类型静态变量
4. 方法区中常量引用的对象，比如字符串常量池(String Table)里的引用
5. 所有被同步锁synchronized持有的对象
6. Java虚拟机内部的应用。基本数据对应的Class对象一些常驻的异常对象(如：NullPointerException、OutOfMemoryError)系统类加载器
7. 反映java虚拟机内部情况的JMXBean、JVMTI中注册的回调、本地代码缓存等。
   
   

除了这些固定的GC Roots集合意外，根据用户所选用的垃圾收集器以及当前回收的内存区域不同，还可以有其他对象“临时性”地加入，共同构成完整GC Roots集合。比如：分代收集和局部回收（Partial GC）。如果只针对Java堆中的某一块区域进行垃圾回收（比如：典型的只针对新生代），必须考虑到内存区域是虚拟机自己的实现细节，更不是孤立封闭的，这个区域的对象完全有可能被其他区域的对象所引用，这时候就需要一并将关联的区域对象也加入GC Roots集合中去考虑，才能保证可达性分析的准确性。

由于Root采用栈方式存放变量和指针，所以如果一个指针，它保存了堆内存里面的对象，但是自己又不存放在堆内存里面，那它就是一个Root

如果使用可达性分析算法来判断内存是否可回收，那么分析工作必须在一个能保障一致性的快照中进行。这点不满足的话分析结果的准确性就无法保证。这点也是导致GC进行时必须“Stop The World”的一个重要原因。即使号称不会发生停顿的CMS收集器中，枚举根节点时也是必须要停顿的。

2.2 垃圾清除阶段算法

当成功区分出内存内存中存活对象和死亡对象后，GC接下来的任务就是执行垃圾回收，释放掉无用对象所占用的内存空间，以便有足够的可用内存空间为新对象分配内存。目前在JVM中比较常见的三种垃圾收集算法是标记–清除算法(Mark-Sweep)、复制算法(Copying)、标记-压缩算法(Mark-Compact)

2.2.1 标记-清除算法

标记-清除算法(Mark-Sweep)是一种非常基础和常见的垃圾收集算法，该算法被J.McCarthy等人在1960年提出并应用于Lisp语言。

当堆中的有效内存空间(available memory)被耗尽的时候，就会停止整个程序(也被称为 stop the world),然后进行两项工作，第一项则是标记，第二项则是清除。
标记: Collector从引用根节点开始便利，标记所有被引用的对象。一般是在对象的Header中记录为可达对象。清除: Collector对堆内存从头到位进行线性的遍历，如果发现某个对象在其Header中没有标记为可达对象，则将其回收。

这种算法的效率比较低(递归与全堆对象遍历两次)。在进行GC的时候，需要停止整个应用程序，导致用户体验很差。这种方式清理出来的空闲内存是不连续的，会产生内存碎片。

这里所谓的清除并不是真的置空，而是把需要清楚的对象地址保存在空闲的地址列表里。下次有新对象需要加载时，判断垃圾的位置空间是否足够。如果够，就存放。

2.2.2 复制算法

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

这种算法没有标记和清除过程，实现简单运行高效。复制过去以后保证空间的连续性，不会出现碎片的问题。但是，此算法的缺点也很明显的，就是需要两倍的内存空间。对于G1这种分拆称为大量region的GC，复制而不是移动，意味着GC需要维护region之间对象引用关系，不管是内存占用或者时间开销也不小。
如果系统中存活对象很多，复制算法不会很理想。因为复制算法需要复制的存活对象数量并不会太大，活着说非常低才行。

在新生代,对常规应用的垃圾回收，一次通常可以回收 70%-99%的内存空间。回收性价比很高，所以现在的商业虚拟机都是使用这种算法回收新生代。
比如:IBM公司的专门研究表明，新生代中80%的对象都是“朝生夕死”的。

2.2.3 标记-压缩算法

复制算法的高效性是建立在存活对象少、垃圾对象多的前提下。这种情况在新生代经常发生，但是在老年代，更常见的情况是大部分对象都是存活对象。如果依然使用复制算法，由于存活对象较多，复制的成本也将很高。因此，基于老年代垃圾回收的特性，需要使用其他的算法。

标记-清除算法的确可以应用在老年代中，但是该算法不仅执行效率低下，而且在执行完内存回收后还会产生内存碎片，所以JVM的设计者需要在此基础上进行改进。标记-压缩(Mark-Compact)算法由此诞生。

标记-压缩算法第一阶段和标记-清除算法一样，从根节点开始标记所有被引用对象。第二阶段将所有的存活对象压缩到内存的一段，按顺序排放。之后，清理边界外所有的空间。

标记-压缩算法的最终效果等同于标记-清除算法执行完成后，在进行一次内存碎片整理。因此，也可以把它称为标记-清除-压缩(Mark-Sweep-Compact)算法。

二者的本质差异在于标记-清除算法是一种非移动式的回收算法，标记-压缩是移动式的。是否移动回收后的存活对象是一项优缺点并存的风险决策。

可以看到，标记的存活对象将会被整理，按照内存地址依次排列，而未被标记的内存会被清理掉。如此一来，当我们需要给新对象分配内存时，JVM只需要持有一个内存的起始地址即可，这比维护一个空闲列表显然少了许多开销。

如果内存空间以规整和有序的方式分布，即已用和未用的内存都各自一边，彼此之间维系着一个记录下一次分配起始点的标记指针。当为新对象分配内存时，只需要通过修改指针的偏移量将新对象分配在第一个空闲内存位置上，这种分配方式就叫做指针碰撞(Bump the Pointer)。

此算法消除了“标记-清除”和“复制”两个算法的弊端。消除了标记/清除算法当中，内存区域分散的缺点，我们需要给新对象分配内存时，JVM只需要持有一个内存的起始地址即可。消除了复制算法当中，内存减半的高额代价。

从效率上来说，标记-压缩算法要低于复制算法。效率不高，不仅要标记所有存活的对象，还要整理所有存活对象的引用地址；对于老年代哪次都有大量对象存活的区域来说，极为负重。移动对象的同时，如果对象被其他对象引用，则还需要调整引用的地址。移动过程中，需要全程暂停用户应用程序，即:STW

2.2.4 分代收集算法

效率上来说，复制算法是当之无愧的老大，但是却浪费了太多内存。而为了尽量兼顾上面提到的三个指标，标记-整理算法相对来说更平滑一些，但是效率上不尽如人意，它比复制算法多了一个标记的阶段，比标记-清除多了一个整理内存的阶段。

分代收集算法，是基于这样一个事实:不同的对象的生命周期是不一样的。因此，不同生命周期的对象可以采取不同的收集方式，以便提高回收效率。一般是把Java堆分为新生代和老年代，这样就可以根据各个年代的特点使用不同的回收算法，以提高垃圾回收的效率。

在Java程序运行的过程中，会产生大量的对象，其中有些对象是与业务信息相关，比如Http请求中的Session对象、线程、Socket连接，这类对象跟业务直接挂钩，因此生命周期比较长。但是还有一些对象，主要是程序运行过程中生成的临时变量，这些对象生命周期会比较短，比如：String对象，由于其不变类的特性，系统会产生大量的这些对象，有些对象甚至只用一次即可回收。

目前几乎所有的GC都是采用分代收集（Generational Collecting）算法执行垃圾回收的。

在HotSpot中，基于分代的概念，GC所使用的内存回收算法必须结合年轻代和老年代各自的特点：
年轻代(Young Gen)
年轻代特点：区域相对老年代较小，对象生命周期短、存活率低，回收频繁。这种情况复制算法的回收整理，速度是最快的。复制算法的效率只和当前存活对象大小有关，因此很适用于年轻代的回收。而复制算法内存利用率不高的问题，通过hotspot中的两个survivor的设计得到缓解。
老年代(Tenured Gen)
老年代特点:区域较大，对象生命周期长、存活率高，回收不及年轻代频繁。这种情况存在大量存活率高的对象，复制算法明显变得不合适。一般由标记-清除或者是标记-清除与标记-整理的混合实现。Mark阶段的考校与存活对象的数量成正比。Sweep阶段的开销与所管理区域的大小成正相关。Compact阶段的开销与存活对象的数据成正比。

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

分代的思想被现有的虚拟机广泛使用。几乎所有的垃圾回收器都区分新生代和老年代。

2.2.5 增量收集算法

上述现有的算法，在垃圾回收过程中，应用软件将处于一种 stop the world 的状态。在stop the world状态下，应用程序所有的线程都会挂起，暂停一切正常的工作，等待垃圾回收的完成。如果垃圾回收时间过长，应用程序会被挂起很久，将严重影响用户体验或者系统的稳定性。为了解决这个问题，即对实时垃圾收集算法的研究直接导致了增量收集(Incremental Collecting)算法的诞生。

如果一次性将所有的垃圾进行处理，需要造成系统长时间的停顿，那么就可以让垃圾收集线程和应用程序线程交替执行。每次，垃圾收集线程只收集一小片区域的内存空间，接着切换到应用程序线程。依次反复，直到垃圾收集完成。

总的来说，增量收集算法的基础仍是传统的标记-清除和复制算法。增量收集算法通过对线程间冲突的妥善处理，允许垃圾收集线程以分阶段的方式完成标记、清理或复制工作。

使用这种方式,由于在垃圾回收过程中，间断性地还执行了应用程序代码，所以能减少系统的停顿时间。但是，因为线程切换和上下文转换的消耗，会是的垃圾回收的总体成本上升，造成系统吞吐量的下降。

2.2.6 分区算法

分代算法将按照对象的生命周期长短划分成两个部分，分区算法将整个堆空间划分成连续的不同小区间。

每一个小区间都独立使用，独立回收。这种算法的好处是可以控制一次回收多个小区间。

一般来说，在相同条件下，堆空间越大，一次GC时所需要的时间就越长，有关GC产生的停顿也越长。为了更好的控制GC产生的停顿时间，将一块大的内存区域分割成多个小块，根据目标的停顿时间，每次合理地回收若干个小区间，而不是整个堆空间，从而减少一次GC所产生的停顿。

3. 相关概念

3.1 System.gc()和finalize()方法详解

System.gc()或者Runtime.getRuntime().gc()的调用，会显示触发Full gc,同时对老年代和新生代进行回收，尝试释放被丢弃对象占用的内存。然而System.gc()调用附带着一个免责声明，无法保证堆垃圾收集器的调用。JVM实现者可以通过System.gc()调用来决定JVMd的GC行为。而一般情况下，垃圾回收应该是自动进行的，无须手动出发，否则就太过于麻烦了。在一些特殊情况下，如果我们正在编写一个性能基准，我们可以在运行之间调用System.gc()。

finalize()是Object的protected方法，子类可以覆盖该方法以实现资源清理工作，GC在回收对象之前调用该方法。

finalize()与C++中的析构函数不是对应的。C++中的析构函数调用的时机是确定的（对象离开作用域或delete掉），但Java中的finalize的调用具有不确定性。不建议用finalize方法完成“非内存资源”的清理工作，但建议用于：① 清理本地对象(通过JNI创建的对象)；② 作为确保某些非内存资源(如Socket、文件等)释放的一个补充：在finalize方法中显式调用其他资源释放方法。

3.2 内存泄漏与内存溢出

内存溢出相对于内存泄漏来说，尽管更容易被理解，但是同样的，内存溢出也是引发程序崩溃的罪魁祸首之一。由于GC一直在发展，所有一般情况下，除非应用程序占用的内存增长速度非常快，造成垃圾回收已经跟不上内存消耗的速度，否则不太容易出现OOM的情况。大多数情况下，GC会进行各种年龄段的垃圾回收，实在不行了就放大招，来一次独占式的Full GC操作，这时候会回收大量的内存，供应用程序继续使用。javadoc中对OutOfMemoryError的解释是，没有空闲内存，并且垃圾收集器也无法提供更多内存。

造成内存不够的原因有如下两个方面:

1. Java虚拟机的对内存设置的不够
   比如：可能存在内存泄漏问题；也很有可能就是堆的大小不合理，比如我们要处理比较可观的数据量，但是没有显式指定JVM堆大小或者指定数值偏小。我们可以通过参数-Xms、-Xmx来调整。
2. 代码中创建了大量大对象，并且长时间不能被垃圾收集器收集(存在被引用)
   对于老版本的Oracle JDK，因为永久代的大小是有限的，并且JVM对永久代垃圾回收（如，常量池回收、卸载不再需要的类型）非常不积极，所以当我们不断添加新类型的时候，永久代出现OutOfMemoryError也非常多见，尤其是在运行时存在大量动态类型生成的场合；类似intern字符串缓存占用太多空间，也会导致OOM问题。对应的异常信息， 会标记出来和永久代相关：“java.lang.OutOfMemoryError: PermGen space”。

随着元数据区的引入，方法区内存已经不再那么窘迫，所以相应的OOM有所改观，出现OOM，异常信息则变成了：“java.lang.OutOfMemoryError: Metaspace”。直接内存不足，也会导致OOM。

内存泄漏(Memory Leak)也称作“存储渗漏”。严格来说，只有对象不会再被程序用到了，但是GC又不能回收他们的情况，才叫内存泄漏。但实际情况很多时候一些不太好的实践（或疏忽）会导致对象的生命周期变得很长甚至导致OOM，也可以叫做宽泛意义上的“内存泄漏”。尽管内存泄漏并不会立刻引起程序崩溃，但是一旦发生内存泄漏，程序中的可用内存就会被逐步蚕食，直至耗尽所有内存，最终出现OutOfMemory异常，导致程序崩溃。注意，这里的存储空间并不是指物理内存，而是指虚拟内存大小，这个虚拟内存大小取决于磁盘交换区设定的大小。


可达性分析算法来判断对象是否是不再使用的对象，本质都是判断一个对象是否还被引用。那么对于这种情况下，由于代码的实现不同就会出现很多种内存泄漏问题（让JVM误以为此对象还在引用中，无法回收，造成内存泄漏）。

内存泄漏与内存溢出的关系：

1. 内存泄漏（memory leak ）
   申请了内存用完了不释放，比如一共有 1024M 的内存，分配了 512M 的内存一直不回收，那么可以用的内存只有 512M 了，仿佛泄露掉了一部分；通俗一点讲的话，内存泄漏就是【占着茅坑不拉shi】。
2. 内存溢出（out of memory）
   申请内存时，没有足够的内存可以使用；通俗一点讲，一个厕所就三个坑，有两个站着茅坑不走的（内存泄漏），剩下最后一个坑，厕所表示接待压力很大，这时候一下子来了两个人，坑位（内存）就不够了，内存泄漏变成内存溢出了。
   可见，内存泄漏和内存溢出的关系：内存泄漏的增多，最终会导致内存溢出。

内存泄漏的分类:

1. 经常发生：发生内存泄漏的代码被多次执行，每次执行泄漏一块内存；
2. 偶然发生：在某些特定情况下才会发生
3. 一次性: 在某些内存泄漏的方法只会执行一次
4. 隐式泄漏:一直占着内存不释放，直到执行结束;严格的说这个不算内存泄漏，因为最终释放掉了。但是如果执行时间特别长，也可能会到这内存耗尽。

Java中内存泄漏的8种情况

1. 静态集合类
   静态集合类，如HashMap、LinkedList等等。如果这些容器为静态的，那么它们的生命周期与JVM程序一致，则容器中的对象在程序结束之前将不能被释放，从而造成内存泄漏。简单而言，长生命周期的对象持有短生命周期对象的引用，尽管短生命周期的对象不再使用，但是因为长生命周期对象持有它的引用而导致不能被回收。

public class MemoryLeak {
    static List list = new ArrayList();

    public void oomTests() {
        Object obj = new Object();//局部变量
        list.add(obj);
    }
}

2. 单例模式
   单例模式，和静态集合导致内存泄露的原因类似，因为单例的静态特性，它的生命周期和 JVM 的生命周期一样长，所以如果单例对象如果持有外部对象的引用，那么这个外部对象也不会被回收，那么就会造成内存泄漏。
3. 内部类持有外部类
   内部类持有外部类，如果一个外部类的实例对象的方法返回了一个内部类的实例对象。这个内部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内部类持有外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄漏。

public class HandlerDemoActivity extends Activity implements OnClickListener {

 

  private static final int MESSAGE_INCRESE = 0;

  private static final int MESSAGE_DECRESE = 1;

  private TextView tv_demo_number;

  private Button btn_demo_increase;

  private Button btn_demo_decrease;

  private Button btn_demo_pause;

  

  private Handler handler = new Handler(){

     //回调方法

     public void handleMessage(android.os.Message msg) {

       String strNum = tv_demo_number.getText().toString();

       //转换为整型数据,获取当前显示的数值

       int num = Integer.parseInt(strNum);

       

       switch(msg.what){

       case MESSAGE_INCRESE:

          num++;

          tv_demo_number.setText(num + "");

          

          if(num == 20){

            Toast.makeText(HandlerDemoActivity.this, "已达到最大值", 0).show();

            btn_demo_pause.setEnabled(false);

            return;

          }

          

          //发送延迟的+1的消息

          sendEmptyMessageDelayed(MESSAGE_INCRESE, 300);//指的是延迟处理，而不是延迟发送

          

          break;

       case MESSAGE_DECRESE:

          num--;

          tv_demo_number.setText(num + "");

          

          

          if(num == 0){

            Toast.makeText(HandlerDemoActivity.this, "已达到最小值", 0).show();

            btn_demo_pause.setEnabled(false);

            return;

          }

          

          //发送延迟的-1的消息

          sendEmptyMessageDelayed(MESSAGE_DECRESE, 300);//指的是延迟处理，而不是延迟发送

          

          break;

       }

       

     }

  };

  

  @Override

  protected void onCreate(Bundle savedInstanceState) {

     super.onCreate(savedInstanceState);

     setContentView(R.layout.activity_handler_demo);

     init();

  }

 

  

  private void init() {

     tv_demo_number = (TextView) findViewById(R.id.tv_demo_number);

     btn_demo_increase = (Button) findViewById(R.id.btn_demo_increase);

     btn_demo_decrease = (Button) findViewById(R.id.btn_demo_decrease);

     btn_demo_pause = (Button) findViewById(R.id.btn_demo_pause);

     

     btn_demo_increase.setOnClickListener(this);

     btn_demo_decrease.setOnClickListener(this);

     btn_demo_pause.setOnClickListener(this);

     

     

  }

 

  @Override

  public void onClick(View v) {

     ....

  }

}

4. 各种链接，如数据库连接、网络连接和IO链接等
   在对数据库进行操作的过程中，首先需要建立与数据库的连接，当不再使用时，需要调用close方法来释放与数据库的连接。只有连接被关闭后，垃圾回收器才会回收对应的对象。否则，如果在访问数据库的过程中，对Connection、Statement或ResultSet不显性地关闭，将会造成大量的对象无法被回收，从而引起内存泄漏。
5. 变量不合理的作用域
   变量不合理的作用域。一般而言，一个变量的定义的作用范围大于其使用范围，很有可能会造成内存泄漏。另一方面，如果没有及时地把对象设置为null，很有可能导致内存泄漏的发生。

public class UsingRandom {

     private String msg;

     public void receiveMsg(){

        //private String msg;

        readFromNet();// 从网络中接受数据保存到msg中

        saveDB();// 把msg保存到数据库中

        //msg = null;

     }

}

如上面这个伪代码，通过readFromNet方法把接受的消息保存在变量msg中，然后调用saveDB方法把msg的内容保存到数据库中，此时msg已经就没用了，由于msg的生命周期与对象的生命周期相同，此时msg还不能回收，因此造成了内存泄漏。
实际上这个msg变量可以放在receiveMsg方法内部，当方法使用完，那么msg的生命周期也就结束，此时就可以回收了。还有一种方法，在使用完msg后，把msg设置为null，这样垃圾回收器也会回收msg的内存空间。
6. 改变哈希值
改变哈希值，当一个对象被存储进HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了。否则，对象修改后的哈希值与最初存储进HashSet集合中时的哈希值就不同了，在这种情况下，即使在contains方法使用该对象的当前引用作为的参数去HashSet集合中检索对象，也将返回找不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象，造成内存泄漏。这也是 String 为什么被设置成了不可变类型，我们可以放心地把 String 存入 HashSet，或者把 String 当做 HashMap 的 key 值；当我们想把自己定义的类保存到散列表的时候，需要保证对象的 hashCode 不可变。

/**
 * 演示内存泄漏
 *
 * @author shkstart
 * @create 14:43
 */

 

public class ChangeHashCode {
    public static void main(String[] args) {
        HashSet set = new HashSet();
        Person p1 = new Person(1001, "AA");
        Person p2 = new Person(1002, "BB");

        set.add(p1);
        set.add(p2);
        p1.name = "CC";
        set.remove(p1);
        System.out.println(set);//2个对象！
        
//        set.add(new Person(1001, "CC"));
//        System.out.println(set);
//        set.add(new Person(1001, "AA"));
//        System.out.println(set);

    }
}

class Person {
    int id;
    String name;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;

        Person person = (Person) o;

        if (id != person.id) return false;
        return name != null ? name.equals(person.name) : person.name == null;
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

 

举例2:

/**
 * 演示内存泄漏
 * @author shkstart
 * @create 14:47
 */
public class ChangeHashCode1 {
    public static void main(String[] args) {
        HashSet<Point> hs = new HashSet<Point>();
        Point cc = new Point();
        cc.setX(10);//hashCode = 41
        hs.add(cc);
        cc.setX(20);//hashCode = 51
        System.out.println("hs.remove = " + hs.remove(cc));//false
        hs.add(cc);
        System.out.println("hs.size = " + hs.size());//size = 2
    }

}

class Point {
    int x;

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + x;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null) return false;
        if (getClass() != obj.getClass()) return false;
        Point other = (Point) obj;
        if (x != other.x) return false;
        return true;
    }

7. 缓存泄漏
   内存泄漏的另一个常见来源是缓存，一旦你把对象引用放入到缓存中，他就很容易遗忘。比如：之前项目在一次上线的时候，应用启动奇慢直到夯死，就是因为代码中会加载一个表中的数据到缓存（内存）中，测试环境只有几百条数据，但是生产环境有几百万的数据。对于这个问题，可以使用WeakHashMap代表缓存，此种Map的特点是，当除了自身有对key的引用外，此key没有其他引用那么此map会自动丢弃此值。

/**
 * 演示内存泄漏
 *
 * @author shkstart
 * @create 14:53
 */
public class MapTest {
    static Map wMap = new WeakHashMap();
    static Map map = new HashMap();

    public static void main(String[] args) {
        init();
        testWeakHashMap();
        testHashMap();
    }

    public static void init() {
        String ref1 = new String("obejct1");
        String ref2 = new String("obejct2");
        String ref3 = new String("obejct3");
        String ref4 = new String("obejct4");
        wMap.put(ref1, "cacheObject1");
        wMap.put(ref2, "cacheObject2");
        map.put(ref3, "cacheObject3");
        map.put(ref4, "cacheObject4");
        System.out.println("String引用ref1，ref2，ref3，ref4 消失");

    }

    public static void testWeakHashMap() {

        System.out.println("WeakHashMap GC之前");
        for (Object o : wMap.entrySet()) {
            System.out.println(o);
        }
        try {
            System.gc();
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("WeakHashMap GC之后");
        for (Object o : wMap.entrySet()) {
            System.out.println(o);
        }
    }

    public static void testHashMap() {
        System.out.println("HashMap GC之前");
        for (Object o : map.entrySet()) {
            System.out.println(o);
        }
        try {
            System.gc();
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("HashMap GC之后");
        for (Object o : map.entrySet()) {
            System.out.println(o);
        }
    }

}
/**
 * 结果
 * String引用ref1，ref2，ref3，ref4 消失
 * WeakHashMap GC之前
 * obejct2=cacheObject2
 * obejct1=cacheObject1
 * WeakHashMap GC之后
 * HashMap GC之前
 * obejct4=cacheObject4
 * obejct3=cacheObject3
 * Disconnected from the target VM, address: '127.0.0.1:51628', transport: 'socket'
 * HashMap GC之后
 * obejct4=cacheObject4
 * obejct3=cacheObject3
 **/

上面代码和图示主演演示WeakHashMap如何自动释放缓存对象，当init函数执行完成后，局部变量字符串引用weakd1,weakd2,d1,d2都会消失，此时只有静态map中保存中对字符串对象的引用，可以看到，调用gc之后，HashMap的没有被回收，而WeakHashMap里面的缓存被回收了。

8. 监听器和回调
   内存泄漏另一个常见来源是监听器和其他回调，如果客户端在你实现的API中注册回调，却没有显式的取消，那么就会积聚。需要确保回调立即被当作垃圾回收的最佳方法是只保存它的弱引用，例如将他们保存成为WeakHashMap中的键。

3.4 垃圾回收的并行与并发

并发和并行，在谈论垃圾收集器的上下文语境中，它们可以解释如下：

1. 并行（Parallel）：指多条垃圾收集线程并行工作，但此时用户线程仍处于等待状态。
   

2. 串行（Serial）相较于并行的概念，单线程执行。如果内存不够，则程序暂停，启动jvm垃圾回收器进行垃圾回收。回收完，在启动程序的线程

3. 并发(Concurrent)：指用户线程与垃圾收集线程同时执行（但不一定是并行的，可能会交替执行），垃圾回收线程在执行时不会停顿用户程序的运行。用户程序在继续运行，而垃圾收集程序线程运行于另一个CPU上；
   

并发是指在操作系统中一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理器上运行。并发不是真正意义上的“同时进行”，只是CPU把一个时间段划分成几个时间片段(时间区间)，然后在这几个时间区间之间来回切换，由于CPU处理的速度非常快，只要时间间隔处理得当，即可让用户感觉是多个应用程序同时在进行。

并行当系统有一个以上CPU时，当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进程互不抢占CPU资源，可以同时进行，我们称之为并行(Parallel)。其实决定并行的因素不是CPU的数量，而是CPU的核心数量，比如一个CPU多个核也可以并行。

3.5 安全点与安全区域

程序执行时并非在所有地方都能停顿下来开始 GC，只有在特定的位置才能停顿下来开始GC，这些位置称为“安全点（Safepoint）”。Safe Point的选择很重要，如果太少可能导致GC等待的时间太长，如果太频繁可能导致运行时的性能问题。大部分指令的执行时间都非常短暂，通常会根据“是否具有让程序长时间执行的特征”为标准。比如：选择一些执行时间较长的指令作为Safe Point，如方法调用、循环跳转和异常跳转等。

如何在GC发生时，检查所有线程都跑到最近的安全点停顿下来呢？一种是主动中断:设置一个中断标志，各个线程运行到Safe Point的时候主动轮询这个标志，如果中断标志为真，则将自己进行中断挂起。另外一种是:抢先式中断(目前没有虚拟机采用了),首先中断所有线程。如果还有线程不在安全点，就恢复线程，让线程跑到安全点。

Safepoint 机制保证了程序执行时，在不太长的时间内就会遇到可进入 GC 的 Safepoint 。但是，程序“不执行”的时候呢？例如线程处于 Sleep 状态或 Blocked 状态，这时候线程无法响应 JVM 的中断请求，“走”到安全点去中断挂起，JVM 也不太可能等待线程被唤醒。对于这种情况，就需要安全区域（Safe Region）来解决。安全区域是指在一段代码片段中，对象的引用关系不会发生变化，在这个区域中的任何位置开始GC都是安全的。我们也可以把 Safe Region 看做是被扩展了的 Safepoint。实际执行时:

1. 当线程运行到Safe Region的代码时，首先标识已经进入了Safe Region，如果这段时间内发生GC，JVM会忽略标识为Safe Region状态的线程；
2. 当线程即将离开Safe Region时，会检查JVM是否已经完成GC，如果完成了，则继续运行，否则线程必须等待直到收到可以安全离开Safe Region的信号为止；

3.6 5种引用

强引用(Strong Reference)不回收
在Java程序中，最常见的引用类型是强引用（普通系统99%以上都是强引用），也就是我们最常见的普通对象引用，也是默认的引用类型。当在Java语言中使用new操作符创建一个新的对象，并将其赋值给一个变量的时候，这个变量就成为指向该对象的一个强引用。强引用的对象是可触及的，垃圾收集器就永远不会回收掉被引用的对象。对于一个普通的对象，如果没有其他的引用关系，只要超过了引用的作用域或者显式地将相应（强）引用赋值为null，就是可以当做垃圾被收集了，当然具体回收时机还是要看垃圾收集策略。相对的， 软引用、弱引用和虚引用的对象是软可触及、弱可触及和虚可触及的，在一定条件下，都是可以被回收的。所以，强引用是造成Java内存泄漏的主要原因之一。
强引用的例子：
StringBuffer str = new StringBuffer (“Hello,尚硅谷”);
局部变量str指向StringBuffer实例所在堆空间，通过str可以操作该实例， 那么str就是StringBuffer实例的强引用。
强引用具有一下的特点:

1. 强引用可以直接访问目标对象
2. 强引用所指向的对象在任何时候都不会被系统回收，虚拟机宁愿抛出OOM异常，也不会回收强引用所指向的对象
3. 强引用可能导致内存泄漏
   软引用(Soft Reference)内存不足即回收
   软引用是用来描述一些还有用，但非必需的对象。只被软引用关联着的对象，在系统将要发生内存溢出异常前，会把这些对象列进回收范围之中进行第二次回收，如果这次回收还没有足够的内存，才会抛出内存溢出异常。软引用通常用来实现内存敏感的缓存。比如：高速缓存就有用到软引用。如果还有空闲内存，就可以暂时保留缓存，当内存不足时清理掉，这样就保证了使用缓存的同时，不会耗尽内存。垃圾回收器在某个时刻决定回收软可达的对象的时候，会清理软引用，并可选地把引用存放到一个引用队列（Reference Queue）。类似弱引用，只不过Java虚拟机会尽量让软引用的存活时间长一些，迫不得已才清理。在JDK 1.2版之后提供了java.lang.ref.SoftReference类来实现软引用。SoftReference< Object> sf = new SoftReference< Object>(obj);
   弱引用(Weak Reference)发现即回收
   弱引用也是用来描述那些非必需对象，只被弱引用关联的对象只能生存到下一次垃圾收集发生为止。在系统GC时，只要发现弱引用，不管系统堆空间使用是否充足，都会回收掉只被弱引用关联的对象。但是，由于垃圾回收器的线程通常优先级很低，因此, 并不一定能很快地发现持有弱引用的对象。在这种情况下，弱引用对象可以存在较长的时间。弱引用和软引用一样，在构造弱引用时，也可以指定一个引用队列，当弱引用对象被回收时，就会加入指定的引用队列，通过这个队列可以跟踪对象的回收情况。弱引用非常适合来保存那些可有可无的缓存数据。如果这么做，当系统内存不足时，这些缓存数据会被回收，不会导致内存溢出。而当内存资源充足时，这些缓存数据又可以存在相当长的时间，从而起到加速系统的作用。在JDK 1.2版之后提供了java.lang.ref.WeakReference类来实现弱引用。WeakReference< Object> wr = new WeakReference< Object>(obj);弱引用对象与软引用对象的最大不同就在于，当GC在进行回收时，需要通过算法检查是否回收软引用对象，而对于弱引用对象，GC总是进行回收。弱引用对象更容易、更快被GC回收。
   虚引用(Phantom Reference)对象回收跟踪
   也称为“幽灵引用”或者“幻影引用”，是所有引用类型中最弱的一个。一个对象是否有虚引用的存在，完全不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它和没有引用几乎是一样的，随时都可能被垃圾回收器回收。它不能单独使用，也无法通过虚引用来获取被引用的对象。当试图通过虚引用的get()方法取得对象时，总是null。为一个对象设置虚引用关联的唯一目的在于跟踪垃圾回收过程。比如：能在这个对象被收集器回收时收到一个系统通知。虚引用必须和引用队列一起使用。虚引用在创建时必须提供一个引用队列作为参数。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象后，将这个虚引用加入引用队列，以通知应用程序对象的回收情况。由于虚引用可以跟踪对象的回收时间，因此，也可以将一些资源释放操作放置在虚引用中执行和记录。JDK 1.2版之后提供了PhantomReference类来实现虚引用。

Object obj = new Object();
ReferenceQueue phantomQueue = new ReferenceQueue();
PhantomReference<Object> pf = new PhantomReference<Object>(obj, phantomQueue);
obj = null;

终结器引用(Final Reference)
用以实现对象的finalize()方法，也可以称为终结器引用。无需手动编码，其内部配合引用队列使用。GC时，终结器引用入队。由Finalizer线程通过终结器引用找到被引用对象并调用它的finalize()方法，第二次GC时才能回收被引用对象。

4. 垃圾回收器

4.1 GC分类

1. 按照线程数分，可以分为串行垃圾回收器和并行垃圾回收器
   
   串行回收指的是在同一时间段内只允许有一个CPU用于执行垃圾回收操作，此时工作线程被暂停，直至垃圾收集工作结束。在诸如单CPU处理器或者较小的应用内存等硬件平台不是特别优越的场合，串行回收器的性能表现可以超过并行回收器和并发回收器。所以，串行回收默认被应用在客户端的Client模式下的JVM中。在并发能力比较强的CPU上，并行回收器产生的停顿时间要短于串行回收器。和串行回收相反，并行收集可以运用多个CPU同时执行垃圾回收，因此提升了应用的吞吐量，不过并行回收仍然与串行回收一样，采用独占式，使用了“Stop-the-world”机制。

2. 按照工作模式分，可以分为并发式垃圾回收器和独占式垃圾回收器
   并发式垃圾回收器与应用程序线程交替工作，以尽可能减少应用程序的停顿时间。独占式垃圾回收器(Stop the world)一旦运行，就停止应用程序中的所有用户线程，直到垃圾回收过程完全结束。
   

3. 按照碎片处理方式分，可以分为压缩式垃圾回收器和非压缩式垃圾回收器
   压缩式垃圾回收器会在回收完成后，对存活对象进行压缩整理，消除回收后的碎片。在分配对象空间使用指针碰撞。非压缩式的垃圾回收器不进行这步操作，再分配对象空间使用的是空闲列表

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

4.2 GC评估指标

1. 吞吐量：程序运行时间(程序运行时间+内存回收的时间)
   
   吞吐量就是CPU用于运行用户代码的时间与CPU总消耗时间的比值，即吞吐量 = 运行用户代码时间 /（运行用户代码时间 + 垃圾收集时间）。比如:虚拟机总共运行了100分钟，其中垃圾收集花掉1分钟，那吞吐量就是99%。这种情况下，应用程序能容忍较高的暂停时间。因此，高吞吐量的应用程序有更长的时间基准，快速响应是不必考虑的。吞吐量优先，意味着在单位时间内，STW的时间最短。吞吐量优先:单位时间内，STW的时间最短:0.2+0.2=0.4
2. 垃圾收集开销：吞吐量的补数，垃圾收集器所占时间与总时间的比例
3. 暂停时间:执行垃圾收集时，程序的工作线程被暂停的时间
   暂停时间指一个时间段内应用程序线程暂停，让GC线程执行的状态。例如：GC期间100毫秒的暂停时间意味着在这100毫秒期间内没有应用程序线程是活动的。暂停时间优先，意味着尽可能让单次STW的时间最短:0.1+0.1+0.1+0.1+0.1=0.5
4. 收集频率:相对于应用程序的执行，收集操作发生的频率。
5. 内存占用:Java堆区所占的内存的大小
6. 快速:一个对象从诞生到被回收所经历的时间。

吞吐量、暂停时间和内存占用共同构成一个不可能三角。三者总体的表现会随着技术进步而越来越好。一款优秀的收集器通常最多同时满足其中的两项。这三项里，暂停时间的重要性日益凸显。因为随着硬件发展，内存占用多些越来越能容忍，硬件性能的提升也有助于降低收集器运行时对应用程序的影响，即提高了吞吐量。而内存的扩大，对延迟反而带来负面效果。

现在JVM的调优标准:在最大吞吐量优先的情况下，降低停顿时间。

4.3 垃圾回收器都有哪些

1. 串行回收器:Serial、Serial Old
2. 并行回收器:ParNew、Parallel Scavenge、Parallel Old
3. 并发回收器:CMS、G1
   7款经典收集器与垃圾分代之间的关系
   

不同厂商、不同版本的虚拟机实现差别很大。HotSpot虚拟机在JDK7/8后所有收集器及组合（连线），如下图：（更新到了JDK14）

1. 两个收集器间有连线，表明他们可以搭配使用
2. 其中Serial Old作为CMS出现"Concurrent Mode Failure"失败的后备预案。
3. (红色虚线)由于维护和兼容性测试的成本，在JDK 8时将Serial+CMS、ParNew+Serial Old这两个组合声明为废弃（JEP 173），并在JDK 9中完全取消了这些组合的支持（JEP214），即：移除。
4. (绿色虚线)JDK 14中：弃用Parallel Scavenge和SerialOld GC组合 （JEP 366）
5. (青色虚线)JDK 14中：删除CMS垃圾回收器 （JEP 363）

之所以使用这么多的垃圾收集器是因为Java的使用场景很多，移动端，服务器等。所以就需要针对不同的场景，提供不同的垃圾收集器，提高垃圾收集的性能。虽然我们会对各个收集器进行比较，但并非为了挑选一个最好的收集器出来。没有一种放之四海皆准、任何场景下都适用的完美收集器存在，更加没有万能的收集器。所以我们选择的只是对具体应用最合适的收集器。查看使用的垃圾收集器可以使用命令-XX:+PrintCommandLineFlags

4.3.1 Serial GC:串行化回收

Serial收集器是最基本、历史最悠久的垃圾收集器了。JDK1.3之前回收新生代唯一的选择。作为HotSpot中Client模式下的默认新生代垃圾收集器。采用复制算法、串行回收和”Stop-the-World”机制的方式执行内存回收。除了年轻代之外，Serial收集器还提供用于执行老年代垃圾收集的Serial Old收集器。Serial Old 收集器同样也采用了串行回收和”Stop the World”机制，只不过内存回收算法使用的是标记-压缩算法。Serial Old在Server模式下主要有两个用途：与新生代的Parallel Scavenge配合使用 ，作为老年代CMS收集器的后备垃圾收集方案

这个收集器是一个单线程的收集器，但它的“单线程”的意义并不仅仅说明它只会使用一个 CPU 或一条收集线程去完成垃圾收集工作，更重要的是在它进行垃圾收集时，必须暂停其他所有的工作线程，直到它收集结束（Stop The World）。
在 HotSpot虚拟机中，使用 -XX:+UseSerialGC 参数可以指定年轻代和老年代都使用串行收集器。

4.3.2 ParNew GC 并行化回收

4.3.3 Parallel GC吞吐量优先

HotSpot的年轻代中除了拥有ParNew收集器是基于并行回收的以外，Parallel Scavenge收集器同样也采用了复制算法、并行回收和”Stop the World”机制。和ParNew收集器不同，Parallel Scavenge收集器的目标则是达到一个可控制的吞吐量（Throughput），它也被称为吞吐量优先的垃圾收集器。自适应调节策略也是Parallel Scavenge与ParNew一个重要区别。高吞吐量则可以高效率地利用 CPU 时间，尽快完成程序的运算任务，主要适合在后台运算而不需要太多交互的任务。因此，常见在服务器环境中使用。例如，那些执行批量处理、订单处理、工资支付、科学计算的应用程序。Parallel 收集器在JDK1.6时提供了用于执行老年代垃圾收集的Parallel Old收集器，用来代替老年代的Serial Old收集器。Parallel Old收集器采用了标记-压缩算法，但同样也是基于并行回收和”Stop-the-World”机制。

在程序吞吐量优先的应用场景中， Parallel 收集器和Parallel Old收集器的组合，在Server模式下的内存回收性能很不错。Java8中，默认是此垃圾收集器。

参数配置

• -XX:+UseParallelGC  手动指定年轻代使用Parallel并行收集器执行内存回收任务。
• -XX:+UseParallelOldGC  手动指定老年代都是使用并行回收收集器。
  • 分别适用于新生代和老年代。默认jdk8是开启的。
  • 上面两个参数，默认开启一个，另一个也会被开启。（互相激活）
• -XX:ParallelGCThreads 设置年轻代并行收集器的线程数。一般地，最好与CPU数量相等，以避免过多的线程数影响垃圾收集性能。
  • 在默认情况下，当CPU 数量小于8个， ParallelGCThreads 的值等于CPU 数量。
  • 当CPU数量大于8个，ParallelGCThreads 的值等于3+[5*CPU_Count]/8] 。
• -XX:MaxGCPauseMillis 设置垃圾收集器最大停顿时间(即STW的时间)。单位是毫秒。
  • 为了尽可能地把停顿时间控制在MaxGCPauseMills以内，收集器在工作时会调整Java堆大小或者其他一些参数。
  • 对于用户来讲，停顿时间越短体验越好。但是在服务器端，我们注重高并发，整体的吞吐量。所以服务器端适合Parallel，进行控制。
  • 该参数使用需谨慎。
• -XX:GCTimeRatio 垃圾收集时间占总时间的比例（= 1 / (N + 1))。用于衡量吞吐量的大小。
  • 取值范围（0,100）。默认值99，也就是垃圾回收时间不超过1%。
  • 与前一个-XX:MaxGCPauseMillis参数有一定矛盾性。暂停时间越长，Radio参数就容易超过设定的比例。
• -XX:+UseAdaptiveSizePolicy  设置Parallel Scavenge收集器具有自适应调节策略
  • 在这种模式下，年轻代的大小、Eden和Survivor的比例、晋升老年代的对象年龄等参数会被自动调整，已达到在堆大小、吞吐量和停顿时间之间的平衡点。
  • 在手动调优比较困难的场合，可以直接使用这种自适应的方式，仅指定虚拟机的最大堆、目标的吞吐量（GCTimeRatio）和停顿时间（MaxGCPauseMills），让虚拟机自己完成调优工作。

4.3.4 CMS低延迟

JDK 1.5 时期，HotSpot 推出了一款在强交互应用中几乎可认为有划时代意义的垃圾收集器：CMS (Concurrent-Mark-Sweep)收集器，这款收集器是HotSpot虚拟机中第一款真正意义上的并发收集器，它第一次实现了让垃圾收集线程与用户线程同时工作。CMS收集器的关注点是尽可能缩短垃圾收集时用户线程的停顿时间。停顿时间越短（低延迟）就越适合与用户交互的程序，良好的响应速度能提升用户体验。目前很大一部分的Java应用集中在互联网站或者B/S系统的服务端上，这类应用尤其重视服务的响应速度，希望系统停顿时间最短，以给用户带来较好的体验。CMS收集器就非常符合这类应用的需求。CMS的垃圾收集算法采用了标记-清除算法，并且也会发生STW。

CMS整个过程比之前的收集器要复杂,整个过程分为4个主要阶段，即初始标记阶段、并发标记阶段、重新标记阶段和并发清除阶段。

• 初始标记(Initial-Mark）阶段：在这个阶段中，程序中所有的工作线程都将会因为“Stop-the-World”机制而出现短暂的暂停，这个阶段的主要任务仅仅只是标记出GC Roots能直接关联到的对象。一旦标记完成之后就会恢复之前被暂停的所有应用线程。由于直接关联对象比较小，所以这里的速度非常快。
• 并发标记（Concurrent-Mark）阶段：从GC Roots的直接关联对象开始遍历整个对象图的过程，这个过程耗时较长但是不需要停顿用户线程，可以与垃圾收集线程一起并发运行。
• 重新标记（Remark）阶段：由于在并发标记阶段中，程序的工作线程会和垃圾收集线程同时运行或者交叉运行，因此为了修正并发标记期间，因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录（比如：由不可达变为可达对象的数据），这个阶段的停顿时间通常会比初始标记阶段稍长一些，但也远比并发标记阶段的时间短。
• 并发清除（Concurrent-Sweep）阶段：此阶段清理删除掉标记阶段判断的已经死亡的对象，释放内存空间。由于不需要移动存活对象，所以这个阶段也是可以与用户线程同时并发的

CMS可以实现并发收集和低延迟的优点，但是会有一下的弊端:

• 产生内存碎片,导致并发清除后，用户线程可用的空间不足。在无法分配大对象的情况下，不得不提前触发Full GC。
• 对CPU资源非常敏感.在并发阶段，它虽然不会导致用户停顿，但是会因为占用了一部分线程而导致应用程序变慢，总吞吐量会降低。
• 无法处理浮动垃圾。可能出现“Concurrent Mode Failure”失败而导致另一次 Full GC 的产生。在并发标记阶段由于程序的工作线程和垃圾收集线程是同时运行或者交叉运行的，那么在并发标记阶段如果产生新的垃圾对象，CMS将无法对这些垃圾对象进行标记，最终会导致这些新产生的垃圾对象没有被及时回收，从而只能在下一次执行GC时释放这些之前未被回收的内存空间。

参数配置

• -XX:+UseConcMarkSweepGC 手动指定使用CMS 收集器执行内存回收任务。
  • 开启该参数后会自动将-XX:+UseParNewGC打开。即：ParNew(Young区用)+CMS(Old区用)+Serial Old的组合。
• -XX:CMSlnitiatingOccupanyFraction 设置堆内存使用率的阈值，一旦达到该阈值，便开始进行回收。
  • JDK5及以前版本的默认值为68,即当老年代的空间使用率达到68%时，会执行一次CMS 回收。JDK6及以上版本默认值为92%
  • 如果内存增长缓慢，则可以设置一个稍大的值，大的阈值可以有效降低CMS的触发频率，减少老年代回收的次数可以较为明显地改善应用程序性能。反之，如果应用程序内存使用率增长很快，则应该降低这个阈值，以避免频繁触发老年代串行收集器。因此通过该选项便可以有效降低Full GC 的执行次数。
• -XX:+UseCMSCompactAtFullCollection 用于指定在执行完Full GC后对内存空间进行压缩整理，以此避免内存碎片的产生。不过由于内存压缩整理过程无法并发执行，所带来的问题就是停顿时间变得更长了。
• -XX:CMSFullGCsBeforeCompaction 设置在执行多少次Full GC后对内存空间进行压缩整理。
• -XX:ParallelCMSThreads 设置CMS的线程数量。
  • CMS 默认启动的线程数是（ParallelGCThreads+3)/4，ParallelGCThreads 是年轻代并行收集器的线程数。当CPU 资源比较紧张时，受到CMS收集器线程的影响，应用程序的性能在垃圾回收阶段可能会非常糟糕。

4.3.5 G1 GC 区域化分代式

应用程序所应对的业务越来越庞大、复杂，用户越来越多，没有GC就不能保证应用程序正常进行，而经常造成STW的GC又跟不上实际的需求，所以才会不断地尝试对GC进行优化。G1（Garbage-First）垃圾回收器是在Java7 update 4之后引入的一个新的垃圾回收器，是当今收集器技术发展的最前沿成果之一。与此同时，为了适应现在不断扩大的内存和不断增加的处理器数量，进一步降低暂停时间（pause time），同时兼顾良好的吞吐量。官方给G1设定的目标是在延迟可控的情况下获得尽可能高的吞吐量，所以才担当起“全功能收集器”的重任与期望。

G1是一个并行回收器，它把堆内存分割为很多不相关的区域（Region）（物理上不连续的）。使用不同的Region来表示Eden、幸存者0区，幸存者1区，老年代等。G1 GC有计划地避免在整个Java 堆中进行全区域的垃圾收集。G1 跟踪各个 Region 里面的垃圾堆积的价值大小（回收所获得的空间大小以及回收所需时间的经验值），在后台维护一个优先列表，每次根据允许的收集时间，优先回收价值最大的Region。由于这种方式的侧重点在于回收垃圾最大量的区间（Region），所以我们给G1一个名字：垃圾优先（Garbage First）。

G1（Garbage-First）是一款面向服务端应用的垃圾收集器，主要针对配备多核CPU及大容量内存的机器，以极高概率满足GC停顿时间的同时，还兼具高吞吐量的性能特征。在JDK1.7版本正式启用，移除了Experimental的标识，是JDK 9以后的默认垃圾回收器，取代了CMS 回收器以及Parallel + Parallel Old组合。被Oracle官方称为“全功能的垃圾收集器”。与此同时，CMS已经在JDK 9中被标记为废弃（deprecated）。在jdk8中还不是默认的垃圾回收器，需要使用-XX:+UseG1GC来启用。G1是一款面向服务端应用的垃圾收集器，兼顾吞吐量和停顿时间的GC实现。在JDK1.7版本正式启用，是JDK 9以后的默认GC选项，取代了CMS 回收器。

与其他GC收集器相比，G1使用了全新的分区算法，其特点如下所示

• 并行与并发
• 分代收集
• 空间整合
• 可预测的停顿时间模型

参数配置

• -XX：+UseG1GC   手动指定使用G1收集器执行内存回收任务。
• -XX:G1HeapRegionSize  设置每个Region的大小。值是2的幂，范围是1MB到32MB之间，目标是根据最小的Java堆大小划分出约2048个区域。默认是堆内存的1/2000。
• -XX:MaxGCPauseMillis   设置期望达到的最大GC停顿时间指标(JVM会尽力实现，但不保证达到)。默认值是200ms
• -XX:ParallelGCThread   设置STW时GC线程数的值。最多设置为8
• -XX:ConcGCThreads   设置并发标记的线程数。将n设置为并行垃圾回收线程数(ParallelGCThreads)的1/4左右。
• -XX:InitiatingHeapOccupancyPercent  设置触发并发GC周期的Java堆占用率阈值。超过此值，就触发GC。默认值是45。

4.4 各GC使用场景

截止JDK 1.8，一共有7款不同的垃圾收集器。每一款不同的垃圾收集器都有不同的特点，在具体使用的时候，需要根据具体的情况选用不同的垃圾收集器。

4.5 怎么选择

Java垃圾收集器的配置对于JVM优化来说是一个很重要的选择，选择合适的垃圾收集器可以让JVM的性能有一个很大的提升。选择可以遵循一下几点:

• 优先调整堆的大小让JVM自适应完成
• 如果内存小于100M,使用串行收集器
• 如果是单核、单机程序，并且没有停顿时间的要求，串行收集器
• 如果是多CPU、需要高吞吐量、允许停顿时间超过1秒，选择并行收集器
• 如果是多CPU、追求低停顿时间，需快速响应（比如延迟不能超过1秒，如互联网应用），使用并发收集器
  官方推荐G1，性能高。现在互联网的项目，基本都是使用G1。
  最后需要明确两个观点:
• 没有最好的收集器，更没有万能的收集器
• 调优永远是针对特定场景，特定需求，不存在一劳永逸的收集器

4.6 GC新发展

5. GC日志分析

5.1 GC日志参数

• -verbose:gc输出gc日志信息,默认输出到标准输出
• -XX:+PrintGC输出GC日志。类似-verbose:gc
• -XX:+PrintGCDetails在发生垃圾回收时打印内存回收详细的日志，并在晋城退出时输出当前内存各区域分配情况
• -XX:+PrintGCTimeStamps输出GC发生的时间戳
• -XX:+PrintGCDateStamps输出GC发生的时间戳(以日期的形式，如：2013-05-04T2:53:39.234+0800)
• -XX:+PrintHeapAtGC每一次GC前和GC后，都打印堆信息
• -Xloggc:<file>表示把GC日志写入到一个文件中去，而不是打印到标准输出中

5.2 GC日志格式

5.2.1 GC日志分类

MinorGC
MinorGC(或young GC或YGC)日志：
[GC (Allocation Failure) [PSYoungGen: 31744K->2192K(36864K)] 31744K->2200K(121856K), 0.0139308 secs]-[Times: user=0.05 sys=0.01, real=0.01 secs]

FullGC
[Full GC (Metadata GC Threshold) [PSYoungGen: 5104K->0K(132096K)] [ParOldGen: 416K->5453K(50176K)] 5520K->5453K(182272K), [Metaspace: 20637K->20637K(1067008K)], 0.0245883 secs] -[Times: user=0.06 sys=0.00, real=0.02 secs]

5.2.2 GC日志结构剖析

垃圾收集器

• 使用Serial收集器在新生代的名字是Default New Generation，因此显示的是"[DefNew"
• 使用ParNew收集器在新生代的名字会变成"[ParNew",意思是"Parallel New Generation"
• 使用Parallel Scavenge收集器在新生代的名字是"[PSYoungGen"
• 使用Parallel Old Generation收集器在老年代的名字是"[ParOldGen"
• 使用G1收集器的话，会显示为"garbage-first heap"
  Allocation Failure表明本次引起GC的原因是因为在年轻代中没有足够的空间能够存储新的数据了

GC前后情况
通过图示，我们可以发现GC日志格式的规律一般都是：GC前内存占用—>GC后内存占用（该区域内存总大小）
[PSYoungGen: 5986K->696K(8704K)] 5986K->704K(9216K) 中括号内：GC回收前年轻代堆大小，回收后大小，（年轻代堆总大小）,括号外：GC回收前年轻代和老年代大小，回收后大小，（年轻代和老年代总大小）

GC时间
GC日志中有三个时间:user,sys和real

• user: 进程执行用户态代码（核心之外）所使用的时间。这是执行此进程所使用的实际 CPU 时间，其他进程和此进程阻塞的时间并不包括在内。在垃圾收集的情况下，表示 GC 线程执行所使用的 CPU 总时间。
• sys:进程在内核态消耗的 CPU 时间，即在内核执行系统调用或等待系统事件所使用的 CPU 时间
• real:程序从开始到结束所用的时钟时间。这个时间包括其他进程使用的时间片和进程阻塞的时间（比如等待 I/O 完成）。对于并行gc，这个数字应该接近（用户时间+系统时间）除以垃圾收集器使用的线程数。
  由于多核的原因，一般的GC事件中，real time是小于sys + user time的，因为一般是多个线程并发的去做GC，所以real time是要小于sys+user time的。如果real>sys+user的话，则你的应用可能存在下列问题：IO负载非常重或者是CPU不够用。

5.2.3 Minor GC日志解析

2020-11-20T17:19:43.265-0800: 0.822: [GC (ALLOCATION FAILURE) [PSYOUNGGEN: 76800K->8433K(89600K)] 76800K->8449K(294400K), 0.0088371 SECS] [TIMES: USER=0.02 SYS=0.01, REAL=0.01 SECS]

• 2020-11-20T17:19:43.265-0800:日志打印时间,日期格式
• 0.822:gc发生时,Java虚拟机启动以来经过的秒数
• [GC (ALLOCATION FAILURE): ] 发生了一次垃圾回收,这是一次Minor GC。他不区分新生代GC还是老年代GC。括号里的内容是gc发生的原因。这里的ALLOCATION FAILURE的原因是新生代中没有足够区域能够存放需要分配的数据而失败
• [PSYOUNGGEN: 76800K->8433K(89600K)] PSYOUNGGEN表示发生gc的区域，区域名称与使用的GC收集器是密切县骨干的。老年代和新生代同理，也是和收集器的名称相关。76800K->8433K(89600K)GC前该内存区域已使用容量-> GC后该区域容量(该区域总容量)。如果是新生代总容量则会显示整个新生代内存的9/10，即eden+from/to区。如果是老年代，总容量则是全部内存大小，无变化
• 76800K->8449K(294400K)：在现实完区域容量GC情况之后，会接着现实整个堆内存区域的GC情况；GC前堆内存已使用容量->GC堆内存容量(堆内存总容量) 堆内存总容量=9/10 新生代+老年代 < 初始化的内存大小
• 0.0088371 SECS]整个GC所花费的时间,单位是秒
• [TIMES: USER=0.02 SYS=0.01, REAL=0.01 SECS] user:指的是CPU工作在用户态所花费的时间；sys指的是CPU工作在内核态所花费的时间；ral指的是在此次GC事件中所花费的总时间

5.2.4 Full GC日志解析

2020-11-20T17:19:43.794-0800: 1.351: [FULL GC (METADATA GC THRESHOLD) [PSYOUNGGEN: 10082K->0K(89600K)] [PAROLDGEN: 32K->9638K(204800K)] 10114K->9638K(294400K),

[METASPACE: 20158K->20156K(1067008K)], 0.0285388 SECS] [TIMES: USER=0.11 SYS=0.00, REAL=0.03 SECS]

• 2020-11-20T17:19:43.794-0800:日志打印时间,日期格式
• 1.351:gc发生时，Java虚拟机启动以来经过的秒数
• [FULL GC (METADATA GC THRESHOLD)] 发生了一次垃圾回收,这是一次FULL GC。它不区分新生代还是老年代GC。括号里的内容是gc发生的原因，这里的METADATA GC THRESHOLD的原因是Metaspace区不够用了。FULL GC 是jvm自适应调整导致的GC,调用了System.gc()方法。
• [PSYOUNGGEN: 10082K->0K(89600K)] PSYOUNGGEN表示发生gc的区域，区域名称与使用的GC收集器是密切县骨干的。老年代和新生代同理，也是和收集器的名称相关。10082K->0K(89600K)GC前该内存区域已使用容量-> GC后该区域容量(该区域总容量)。如果是新生代总容量则会显示整个新生代内存的9/10，即eden+from/to区。如果是老年代，总容量则是全部内存大小，无变化
• [PAROLDGEN: 32K->9638K(204800K)] 老年代区域没有发生GC,因为本次GC是metaspace引起的
• 10114K->9638K(294400K),在现实完区域容量GC的情况之后，会接着现实整个堆内存区域的GC情况：GC前堆内存已使用容量 -> GC堆内存容量(堆内存总容量)。堆内存总容量 = 9/10新生代+老年代 < 初始化的内存大小
• [METASPACE: 20158K->20156K(1067008K)] metaspace回收2k空间
• [METASPACE: 20158K->20156K(1067008K)] 整个GC所花费的时间,单位是秒
• [TIMES: USER=0.11 SYS=0.00, REAL=0.03 SECS] user:指的是CPU工作在用户态所花费的时间；sys指的是CPU工作在内核态所花费的时间；ral指的是在此次GC事件中所花费的总时间

5.3 案例演示

/**
 * 在jdk7 和 jdk8中分别执行
 *  * -verbose:gc -Xms20M -Xmx20M -Xmn10M -XX:+PrintGCDetails -XX:SurvivorRatio=8 -XX:+UseSerialGC
 * @author shkstart  shkstart@126.com
 * @create 2020  0:12
 */
public class GCLogTest1 {
    private static final int _1MB = 1024 * 1024;

    public static void testAllocation() {
        byte[] allocation1, allocation2, allocation3, allocation4;
        allocation1 = new byte[2 * _1MB];
        allocation2 = new byte[2 * _1MB];
        allocation3 = new byte[2 * _1MB];
        allocation4 = new byte[4 * _1MB];
    }

    public static void main(String[] agrs) {
        testAllocation();
    }
}

在JDK7中

5.4 GC日志分析工具

5.4.1 GCeasy

官网地址：https://gceasy.io/，GCeasy是一款在线的GC日志分析器，可以通过GC日志分析进行内存泄漏检测、GC暂停原因分析、JVM配置建议优化等功能，而且是可以免费使用的（有一些服务是收费的）。

5.4.2 GCViewer

GCViewer是一个免费的、开源的分析小工具，用于可视化查看由SUN/Oracle,IBM,HP和BEA Java虚拟机产生的垃圾收集器的日志。GCViewer用于可视化Java VM选项-verbose:gc 和.NET生成的数据-Xloggc:< file>。它还计算与垃圾回收相关的性能指标（吞吐量，累积的暂停，最长的暂停等）。当通过更改世代大小或设置初始堆大小来调整特定应用程序的垃圾回收时，此功能非常有用。

安装

• 源码下载：https://github.com/chewiebug/GCViewer
• 运行版本下载：https://github.com/chewiebug/GCViewer/wiki/Changelog
• 双击gcviewer-1.3x.jar或运行java -jar gcviewer-1.3x.jar（它需要运行java 1.8 vm），即可启动GCViewer（gui)