一文看懂 Java 垃圾回收
java gc讲解
Java中的垃圾回收（Garbage Collection，GC）是自动内存管理的一种机制。
Java程序员不需要显式地进行内存管理，因为Java虚拟机（JVM）会自动管理内存。
垃圾回收器（GC器）会定期检查堆内存中不再使用的对象，并将其释放，以便其他对象可以使用这些空间。
Java的GC机制基于以下几个原则：
1.对象只有在没有被引用时才会被回收。
垃圾回收器会定期扫描堆内存，找出不再被
引用的对象，并将它们从堆内存中删除。
2.Java虚拟机中的堆内存被分成若干个不同的代。
新创建的对象会被分配到年轻代
（Young Generation），经过多次垃圾回收后，如果仍然存活，则会被移动到年老代（Old Generation）。
年老代中存活时间较长的对象可能会被移动到持久代（Permanent Generation），其中主要存放JVM使用的类信息、方法信息等。
3.垃圾回收器的工作是尽可能快地释放内存，同时保证程序的性能。
为了实现这一目
标，Java中使用了不同类型的垃圾回收器，例如串行回收器、并发标记-清除回收器、并行回收器、G1垃圾回收器等。
每个垃圾回收器都有其优缺点，应根据应用程序的需求进行选择。
Java中的垃圾回收机制可以大大简化程序员的工作，并提高代码的可靠性和稳定性。
但是，Java垃圾回收也会带来一些额外的开销，例如GC停顿时间较长、内存占用较高等问题。
因此，程序员需要了解Java垃圾回收机制的工作原理，并针对具体情况进行调整和优化，以提高程序的性能和可靠性。
深入理解Java垃圾回收机制
深入理解Java垃圾回收机制Java作为一门面向对象的编程语言，其垃圾回收机制是其核心功能之一。
Java垃圾回收机制以其高效、可靠的特性，为程序员们带来了很大的便利。
但对于初学者和一些开发者，Java垃圾回收机制还是比较神秘的。
本文将从深入理解Java垃圾回收机制方面进行探讨。
Java垃圾回收机制的概念对于Java垃圾回收机制，我们首先需要了解的是垃圾回收机制的概念。
简单来说，垃圾回收机制就是在程序运行时，自动清除不再使用的对象，并回收其占用的内存空间。
这样做既能够让程序节省内存空间，也可以避免内存泄漏等问题的发生。
Java垃圾回收机制的执行方式Java垃圾回收机制的执行方式可以分为两种，即标记-清除法和复制-清除法。
1. 标记-清除法标记-清除法是指，当垃圾回收机制开始工作时，它会标记所有正在使用的对象和被使用的对象之间的关系。
然后，它会扫描程序中所有的对象，并将被使用的对象打上“标记”，将不再使用的对象打上“不可达标记”。
最后，垃圾回收机制回收那些被打上“不可达标记”的对象，并释放其占用的内存空间。
2. 复制-清除法复制-清除法是指，当垃圾回收机制开始工作时，它会将整个可用内存区域分为两个相等的部分，分别称为“From”空间和“To”空间。
当程序对象在进行分配内存时，垃圾回收机制会将对象分配在From空间中。
当From空间被占满时，垃圾回收机制会暂停程序运行，并将所有存活的对象从From空间复制到To空间，然后将From空间进行清除，最后将To空间作为新的From空间。
这种方式既能够让内存得到有效的利用，也可以确保程序的稳定运行。
Java垃圾回收机制的内存分区Java垃圾回收机制的内存分区可以分为程序计数器、虚拟机栈、方法区、堆（Heap）四个部分。
其中，程序计数器保存下一个要执行的指令的地址；虚拟机栈保存线程方法的信息；方法区保存类、方法及常量池的信息；堆是程序运行时所使用的内存区域。
Java垃圾回收机制的垃圾收集器Java垃圾回收机制的垃圾收集器是Java虚拟机中专门负责回收垃圾对象的模块，其具体实现方式取决于Java虚拟机的版本和厂商。
Java中的垃圾回收机制是如何工作的
Java中的垃圾回收机制是如何工作的在 Java 编程的世界里，垃圾回收机制是一项至关重要的特性，它就像是一位默默工作的“清洁工”，负责自动管理内存的分配和释放，让开发者能够更专注于业务逻辑的实现，而不必过度操心内存管理的繁琐细节。
要理解 Java 中的垃圾回收机制是如何工作的，首先得明白什么是垃圾。
在 Java 中，当一个对象不再被任何引用所指向，也就是没有任何途径能够访问到它时，这个对象就被视为垃圾。
想象一下，一个对象就像是一个房间，如果没有钥匙能打开这个房间的门，那么这个房间里的东西也就没有用了，它就变成了垃圾。
那么，Java 是如何发现这些垃圾对象的呢？这主要通过两种方式：引用计数法和可达性分析算法。
引用计数法的原理比较简单直观。
给每个对象添加一个引用计数器，每当有一个地方引用这个对象时，计数器就加 1；当引用失效时，计数器就减 1。
当计数器的值为 0 时，就表明这个对象没有被引用，可以被当作垃圾回收。
然而，这种方法存在一个问题，那就是无法解决循环引用的情况。
比如对象 A 引用了对象 B，对象 B 又引用了对象 A，但除此之外没有其他地方引用它们，按照引用计数法，它们的计数器都不为 0，但实际上它们已经不再被使用了，是应该被回收的垃圾。
相比之下，可达性分析算法就更强大和准确。
它从一些被称为“GC Roots”的对象出发，沿着引用链向下搜索。
如果一个对象不能从任何“GC Roots”对象通过引用链到达，那么这个对象就被认为是不可达的，是垃圾。
“GC Roots”对象通常包括虚拟机栈（栈帧中的本地变量表）中引用的对象、方法区中类静态属性引用的对象、方法区中常量引用的对象以及本地方法栈中 JNI（即 Java Native Interface）引用的对象。
当垃圾回收器确定了哪些对象是垃圾之后，就会开始进行回收操作。
Java 的垃圾回收算法主要有标记清除算法、复制算法、标记压缩算法以及分代收集算法。
Java垃圾回收机制（GC）
Java垃圾回收机制（GC）
分类:
1. 什么是GC
2. GC的区域在哪⾥
3. GC的对象是什么
4. GC做了哪些事
需要GC的内存区域
jvm 中，程序记数器、虚拟机栈、本都⽅法栈都是随线程⽽⽣，随线程⽽灭，栈随着⽅法的进⼊和退出做⼊栈和出栈操作，实现了⾃动的内存清理，因此，我们的内存⽴即回收主要集中于java 堆和⽅法区中，在程序运⾏期间，这部分内存的分配和使⽤都是动态的。
GC的对象
需要进⾏回收的对象就是已经没有存活的对象，判断⼀个对象是否存活有两种常⽤的办法:
1. 引⽤计数: 每个对象有⼀个引⽤计数属性，新增⼀个引⽤时计数就加1，引⽤什邡市计数就减1，计数为0时就可以回收。
(⽆法解决对象
互相引⽤的问题。
)
2. 可达分析( Reachability Analysis ): 从 GC Roots开始向下搜索，搜索所⾛过的路径被称为引⽤链。
当⼀个对象到GC Roots没有任何引
⽤链相连时，则证明此对象是不可⽤的。
不可达对象。
GC Roots包括:
1. 虚拟机栈中引⽤的对象。
2. ⽅法区中静态属性实体引⽤对象。
3. ⽅法区中常量引⽤的对象。
4. 本地⽅法栈中JNI引⽤的对象。
什么时候触发GC
1. 程序调⽤System.gc时可以触发
2. 系统⾃⾝来决定GC触发的时机（根据Eden区和From Space区的内存⼤⼩来决定。
当内存⼤⼩不⾜时，则会启动GC线程并停⽌应⽤
线程）
GC做了什么事
主要做了清理对象，整理内存的⼯作。
Java堆分为新⽣代和⽼年代，采⽤了不同的回收⽅式。
综述java运行中垃圾回收机制
综述java运行中垃圾回收机制Java作为一门面向对象的高级编程语言，一直以来都备受程序员们的青睐。
在Java的编写过程中，垃圾回收机制是非常重要的一部分，它可以帮助程序员解决内存泄漏的问题，提高程序的效率和稳定性。
本篇文章将综述Java运行中垃圾回收机制的相关知识，包括垃圾回收原理、垃圾回收算法和垃圾回收器等内容，旨在为程序员们更好地理解和掌握Java垃圾回收机制提供帮助。
一、垃圾回收原理垃圾回收原理是Java垃圾回收机制的核心部分，它是Java虚拟机对内存分配和内存释放机制的实现。
Java中的垃圾回收机制在堆内存分配中起到了至关重要的作用，可以有效地解决程序中出现的内存溢出和内存泄漏问题，提高了程序的效率和稳定性。
下面我们将对Java垃圾回收原理进行详细介绍。
1. 垃圾的定义Java程序中的垃圾指的是没有被任何引用变量引用的对象。
当程序中的某个对象没有被引用时，JVM就会将这个对象视为垃圾，等待垃圾回收器进行回收。
2. 标记清除算法标记清除算法是Java中最常见的垃圾回收算法，它采用了两个阶段进行垃圾回收。
在第一个阶段，垃圾回收器会遍历整个堆中的对象，标记出仍然被引用的对象。
在第二个阶段，回收器会扫描整个堆中未被标记的对象，将其清除并回收内存。
这种算法的缺点在于，会产生大量的内存碎片，导致内存不连续的情况，降低了程序的性能。
3. 复制算法复制算法是Java中另一种常见的垃圾回收算法，它将堆内存划分为两个区域，一个区域存放已标记的对象，另一个区域存放未标记的对象。
在垃圾回收过程中，已标记的对象会被复制到未标记的区域中，未标记的区域会被全部清除，然后两个区域进行角色交换。
这种算法的优点在于，复制操作非常高效，可以避免内存碎片问题，但是同时也需要消耗一部分的内存空间。
4. 标记整理算法标记整理算法是一种比较高效的垃圾回收算法，它采用标记清除算法和复制算法相结合的方式进行内存回收。
在标记清除算法中，由于存在内存碎片问题，因此需要对内存空间进行整理，而标记整理算法就是采用了这种方式来解决问题。
javagc回收机制
javagc回收机制即java垃圾回收机制，是自动的内存管理机制，它可以在程序执行时自动回收无用的对象，以释放内存空间。
Java 中的垃圾回收机制主要包括以下几个方面：
1. 对象的创建和销毁：当一个对象被创建时，Java 虚拟机会为其分配一块内存空间，并记录其在内存中的位置。
当对象不再被引用时，Java 虚拟机会将其标记为垃圾对象，并在适当的时候回收它所占用的内存空间。
2. 垃圾收集算法：Java 中使用的垃圾收集算法主要有标记-清除算法和复制算法。
标记-清除算法会先标记所有还在使用中的对象，然后清除所有未被标记的对象；复制算法则会将内存分为两个区域，将还在使用中的对象复制到其中一个区域，然后清除另一个区域中的所有对象。
3. 垃圾收集器的选择和配置：Java 中提供了多种垃圾收集器，如Serial GC、Parallel GC、CMS GC 等。
可以根据程序的特点和运行环境的需求选择合适的垃圾收集器和配置参数，以达到最优的垃圾回收效果。
4. 垃圾回收的影响：垃圾回收会占用一定的系统资源，可能会影响程序的性能。
因此，在进行垃圾回收时需要注意控制回收的频率和时间，以避免对程序的性能造成过大的影响。
总的来说，Java 中的垃圾回收机制是一个自动化的、高效的内存管理机制，可以帮助开发人员避免内存泄漏等问题，提高程序的稳定性和可靠性。
Java面试题集锦Java中的垃圾回收机制
Java面试题集锦Java中的垃圾回收机制Java面试题集锦：Java中的垃圾回收机制在Java编程语言中，垃圾回收（Garbage Collection）是一个重要的概念。
它是自动管理内存的机制，用于释放不再需要的对象，减轻程序员的内存管理压力。
本文将介绍Java中的垃圾回收机制，包括其原理、优点以及一些常见的面试题。
一、垃圾回收的原理Java中的垃圾回收机制基于自动内存管理原理，通过追踪对象之间的引用关系，判断哪些对象已经不再被使用，从而释放其占用的内存空间。
Java虚拟机（JVM）中的垃圾回收器负责执行垃圾回收的具体工作。
垃圾回收的基本原理是通过可达性分析算法。
简单来说，就是从一些称为根（GC Roots）的对象开始，递归地遍历对象之间的引用关系，标记出所有被引用的对象为存活对象，未被标记的对象即为垃圾对象。
然后，垃圾回收器将回收这些垃圾对象所占用的内存空间。
二、垃圾回收的优点1. 自动回收内存：相比于手动管理内存的编程语言（如C++），Java的垃圾回收机制可以自动回收不被使用的对象，减少了程序员的工作量。
2. 避免内存泄漏：Java的垃圾回收机制可以检测和释放不再被使用的对象，避免了内存泄漏问题，使程序更加健壮和可靠。
3. 提高开发效率：无需手动释放内存，程序员可以将更多时间和精力投入到业务逻辑开发中，提高开发效率和代码质量。
三、常见的面试题1. 什么是垃圾回收机制？为什么使用垃圾回收机制？垃圾回收机制是自动管理内存的原理，用于释放不再需要的对象。
它能够自动回收内存、避免内存泄漏，并提高开发效率。
2. 如何判断对象是否可以被回收？Java的垃圾回收机制使用可达性分析算法，通过判断对象是否可由根对象（如局部变量、静态变量等）追溯而来，来确定对象是否可以被回收。
3. 垃圾回收的过程中发生了什么？垃圾回收的过程中，垃圾回收器会通过标记-清除算法或复制算法等方式，将不再需要的对象标记并进行回收。
垃圾回收器知识点总结
垃圾回收器知识点总结垃圾回收（Garbage Collection）是指计算机系统自动回收不再使用的内存空间，以便重新利用。
在众多编程语言中，Java是一种通过垃圾回收器（Garbage Collector，GC）来管理内存的语言。
垃圾回收器是一种特殊的程序，它负责监视和回收在程序运行中不再被使用的对象和变量，以释放内存空间。
在本文中，我们将对垃圾回收器的知识点进行总结，包括垃圾回收的原理、不同类型的垃圾回收器以及优化垃圾回收的方法等方面。
一、垃圾回收的原理在编程语言中，垃圾回收的原理主要包括引用计数法和标记-清除法。
引用计数法：引用计数法是一种最简单的垃圾回收技术，它通过记录每个对象的引用次数来判断其是否应该被回收。
当一个对象的引用次数为0时，表示该对象不再被引用，可以被回收。
然而，引用计数法无法处理循环引用的情况，因此在实际应用中并不常见。
标记-清除法：标记-清除法是一种常见的垃圾回收技术，它通过标记可达对象，然后清除不可达对象来回收内存空间。
在标记阶段，垃圾回收器会从根对象（如全局变量、活动栈等）开始，递归地标记所有可达对象。
在清除阶段，垃圾回收器会清除未被标记的对象，释放其内存空间。
二、不同类型的垃圾回收器在Java中，垃圾回收器主要包括串行垃圾回收器、并行垃圾回收器、CMS垃圾回收器和G1垃圾回收器等多种类型。
串行垃圾回收器：串行垃圾回收器是一种单线程的垃圾回收器，它在进行垃圾回收时会暂停应用程序的运行。
因此，串行垃圾回收器通常用于客户端应用程序和小型服务器应用程序，在这些场景下对暂停时间要求不高。
并行垃圾回收器：并行垃圾回收器是一种多线程的垃圾回收器，它在进行垃圾回收时会使用多个线程同时进行。
并行垃圾回收器通常用于多核处理器的服务器应用程序，在这些场景下对吞吐量要求较高。
CMS垃圾回收器：CMS（Concurrent Mark-Sweep）垃圾回收器是一种使用标记-清除法的并发垃圾回收器，它可以在应用程序运行的同时进行垃圾回收。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
之前上学的时候有这个一个梗，说在食堂里吃饭，吃完把餐盘端走清理的，是 C++ 程序员，吃完直接就走的，是 Java 程序员。
Java 与 C 的区别确实，在 Java 的世界里，似乎我们不用对垃圾回收那么的专注，很多初学者不懂 GC，也依然能写出一个能用甚至还不错的程序或系统。
但其实这并不代表 Java 的 GC 就不重要。
相反，它是那么的重要和复杂，以至于出了问题，那些初学者除了打开 GC 日志，看着一堆0101的天文，啥也做不了。
今天我们就从头到尾完整地聊一聊 Java 的垃圾回收。
什么是垃圾回收垃圾回收（Garbage Collection，GC），顾名思义就是释放垃圾占用的空间，防止内存泄露。
有效的使用可以使用的内存，对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收。
Java 语言出来之前，大家都在拼命的写 C 或者 C++ 的程序，而此时存在一个很大的矛盾，C+ + 等语言创建对象要不断的去开辟空间，不用的时候又需要不断的去释放控件，既要写构造函数，又要写析构函数，很多时候都在重复的 allocated，然后不停的析构。
于是，有人就提出，能不能写一段程序实现这块功能，每次创建，释放控件的时候复用这段代码，而无需重复的书写呢？1960年，基于 MIT 的 Lisp 首先提出了垃圾回收的概念，而这时 Java 还没有出世呢！所以实际上 GC 并不是Java的专利，GC 的历史远远大于 Java 的历史！怎么定义垃圾既然我们要做垃圾回收，首先我们得搞清楚垃圾的定义是什么，哪些内存是需要回收的。
引用计数算法引用计数算法（Reachability Counting）是通过在对象头中分配一个空间来保存该对象被引用的次数（Reference Count）。
如果该对象被其它对象引用，则它的引用计数加1，如果删除对该对象的引用，那么它的引用计数就减1，当该对象的引用计数为0时，那么该对象就会被回收。
String m = new String("jack");先创建一个字符串，这时候”jack”有一个引用，就是 m。
Java 字符串的内存地址然后将 m 设置为 null，这时候”jack”的引用次数就等于0了，在引用计数算法中，意味着这块内容就需要被回收了。
m = null;Java 字符串即将被回收引用计数算法是将垃圾回收分摊到整个应用程序的运行当中了，而不是在进行垃圾收集时，要挂起整个应用的运行，直到对堆中所有对象的处理都结束。
因此，采用引用计数的垃圾收集不属于严格意义上的”Stop-The-World”的垃圾收集机制。
看似很美好，但我们知道 JVM 的垃圾回收就是”Stop-The-World”的，那是什么原因导致我们最终放弃了引用计数算法呢？看下面的例子。
public class ReferenceCountingGC {public Object instance;public ReferenceCountingGC(String name){}}public static void testGC(){ReferenceCountingGC a = new ReferenceCountingGC("objA");ReferenceCountingGC b = new ReferenceCountingGC("objB");a.instance = b;b.instance = a;a = null;b = null;}1. 定义2个对象2. 相互引用3. 置空各自的声明引用内存泄露我们可以看到，最后这2个对象已经不可能再被访问了，但由于他们相互引用着对方，导致它们的引用计数永远都不会为0，通过引用计数算法，也就永远无法通知GC收集器回收它们。
可达性分析算法可达性分析算法（Reachability Analysis）的基本思路是，通过一些被称为引用链（GC Root s）的对象作为起点，从这些节点开始向下搜索，搜索走过的路径被称为（Reference Chain)，当一个对象到 GC Roots 没有任何引用链相连时（即从 GC Roots 节点到该节点不可达），则证明该对象是不可用的。
可达性分析算法（Reachability Analysis）通过可达性算法，成功解决了引用计数所无法解决的问题-“循环依赖”，只要你无法与 GC Ro ot 建立直接或间接的连接，系统就会判定你为可回收对象。
那这样就引申出了另一个问题，哪些属于 GC Root。
Java 内存区域在 Java 语言中，可作为 GC Root 的对象包括以下4种：虚拟机栈（栈帧中的本地变量表）中引用的对象方法区中类静态属性引用的对象方法区中常量引用的对象本地方法栈中 JNI（即一般说的 Native 方法）引用的对象Java 内存区域，运行时数据区虚拟机栈（栈帧中的本地变量表）中引用的对象此时的 s，即为 GC Root，当s置空时，localParameter 对象也断掉了与 GC Root 的引用链，将被回收。
public class StackLocalParameter {public StackLocalParameter(String name){}}public static void testGC(){StackLocalParameter s = new StackLocalParameter("localParameter");s = null;}方法区中类静态属性引用的对象s 为 GC Root，s 置为 null，经过 GC 后，s 所指向的 properties 对象由于无法与 GC Root 建立关系被回收。
而 m 作为类的静态属性，也属于 GC Root，parameter 对象依然与 GC root 建立着连接，所以此时 parameter 对象并不会被回收。
public class MethodAreaStaicProperties {public static MethodAreaStaicProperties m;public MethodAreaStaicProperties(String name){}}public static void testGC(){MethodAreaStaicProperties s = new MethodAreaStaicProperties("properties");s.m = new MethodAreaStaicProperties("parameter");s = null;}方法区中常量引用的对象m 即为方法区中的常量引用，也为 GC Root，s 置为 null 后，final 对象也不会因没有与 GC Ro ot 建立联系而被回收。
public class MethodAreaStaicProperties {public static final MethodAreaStaicProperties m = MethodAreaStaicProperties("final");public MethodAreaStaicProperties(String name){}}public static void testGC(){MethodAreaStaicProperties s = new MethodAreaStaicProperties("staticProperties");s = null;}本地方法栈中引用的对象任何 Native 接口都会使用某种本地方法栈，实现的本地方法接口是使用 C 连接模型的话，那么它的本地方法栈就是 C 栈。
当线程调用 Java 方法时，虚拟机会创建一个新的栈帧并压入 Java 栈。
然而当它调用的是本地方法时，虚拟机会保持 Java 栈不变，不再在线程的 Java 栈中压入新的帧，虚拟机只是简单地动态连接并直接调用指定的本地方法。
调用 Java 方法和本地方法对比怎么回收垃圾在确定了哪些垃圾可以被回收后，垃圾收集器要做的事情就是开始进行垃圾回收，但是这里面涉及到一个问题是：如何高效地进行垃圾回收。
由于Java虚拟机规范并没有对如何实现垃圾收集器做出明确的规定，因此各个厂商的虚拟机可以采用不同的方式来实现垃圾收集器，这里我们讨论几种常见的垃圾收集算法的核心思想。
标记 — 清除算法GC 标记清除算法标记清除算法（Mark-Sweep）是最基础的一种垃圾回收算法，它分为2部分，先把内存区域中的这些对象进行标记，哪些属于可回收标记出来，然后把这些垃圾拎出来清理掉。
就像上图一样，清理掉的垃圾就变成未使用的内存区域，等待被再次使用。
这逻辑再清晰不过了，并且也很好操作，但它存在一个很大的问题，那就是内存碎片。
上图中等方块的假设是 2M，小一些的是 1M，大一些的是 4M。
等我们回收完，内存就会切成了很多段。
我们知道开辟内存空间时，需要的是连续的内存区域，这时候我们需要一个 2M的内存区域，其中有2个 1M 是没法用的。
这样就导致，其实我们本身还有这么多的内存的，但却用不了。
复制算法GC 复制算法复制算法（Copying）是在标记清除算法上演化而来，解决标记清除算法的内存碎片问题。
它将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。
当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后再把已使用过的内存空间一次清理掉。
保证了内存的连续可用，内存分配时也就不用考虑内存碎片等复杂情况，逻辑清晰，运行高效。
上面的图很清楚，也很明显的暴露了另一个问题，合着我这140平的大三房，只能当70平米的小两房来使？代价实在太高。
标记整理算法GC 标记整理算法标记整理算法（Mark-Compact）标记过程仍然与标记 — 清除算法一样，但后续步骤不是直接对可回收对象进行清理，而是让所有存活的对象都向一端移动，再清理掉端边界以外的内存区域。
标记整理算法一方面在标记-清除算法上做了升级，解决了内存碎片的问题，也规避了复制算法只能利用一半内存区域的弊端。
看起来很美好，但从上图可以看到，它对内存变动更频繁，需要整理所有存活对象的引用地址，在效率上比复制算法要差很多。
分代收集算法分代收集算法（Generational Collection）严格来说并不是一种思想或理论，而是融合上述3种基础的算法思想，而产生的针对不同情况所采用不同算法的一套组合拳。
对象存活周期的不同将内存划分为几块。
一般是把 Java 堆分为新生代和老年代，这样就可以根据各个年代的特点采用最适当的收集算法。