下载文档原格式
jvm的gc原理JVM的GC原理一、概述JVM（Java虚拟机）是Java程序运行的环境，其中最重要的组成部分之一就是垃圾回收（Garbage Collection，简称GC）机制。
GC的作用是自动管理程序中的内存，及时释放不再使用的对象，以避免内存泄漏和内存溢出的问题。
本文将对JVM的GC原理进行详细介绍。
二、垃圾回收算法1. 标记-清除算法标记-清除算法是最基本的垃圾回收算法之一。
它的过程分为两个阶段：标记阶段和清除阶段。
在标记阶段，GC会从根节点（一般是程序中的静态变量和栈中的引用）开始，递归地遍历对象图，标记出所有被引用的对象。
在清除阶段，GC会遍历整个堆，清除所有未被标记的对象。
2. 复制算法复制算法是针对标记-清除算法的改进。
它将堆分为两个区域，每次只使用其中一个区域。
当一个区域的对象被标记后，将其复制到另一个区域中，然后清除原来的区域。
这样可以解决碎片问题，但是需要额外的空间来存储复制的对象。
3. 标记-整理算法标记-整理算法是对标记-清除算法的改进。
它的过程与标记-清除算法类似，但是在清除阶段，标记-整理算法会将存活的对象向一端移动，然后清除边界外的所有对象。
这样可以解决碎片问题，并且不需要额外的空间。
4. 分代算法分代算法是针对对象的生命周期不同而提出的。
一般来说，对象的生命周期可以分为年轻代和老年代。
年轻代中的对象生命周期较短，老年代中的对象生命周期较长。
分代算法将堆分为年轻代和老年代两个区域，分别采用不同的垃圾回收算法。
年轻代一般使用复制算法，老年代一般使用标记-清除算法或标记-整理算法。
三、GC的执行过程1. 初始标记初始标记阶段是GC的第一步，它的目的是标记出所有的根对象，并且停止所有的应用线程。
这个过程是短暂的，因为只需要标记出与根对象直接关联的对象。
2. 并发标记并发标记阶段是GC的核心步骤，它的目的是通过并发执行来标记出所有的存活对象。
在这个阶段，GC会遍历整个堆，标记出与根对象直接或间接关联的存活对象。
javaGC垃圾回收机制G1、CMSCMS(Concurrent Mark-Sweep)是以牺牲吞吐量为代价来获得最短回收停顿时间。
对于要求服务器响应速度的应⽤上，这种垃圾回收器⾮常适合。
在启动JVM参数加上-XX:+UseConcMarkSweepGC ，这个参数表⽰对于⽼年代的回收采⽤CMS。
CMS采⽤的基础算法是：标记—清除。
使⽤场景：1、应⽤程序对停顿⽐较敏感，并且在应⽤程序运⾏的时候可以提供更⼤的内存和更多的CPU2、在JVM中，有相对较多存活时间较长的对象(⽼年代⽐较⼤)会更适合使⽤CMS。
为解决CMS算法产⽣空间碎⽚和其它⼀系列的问题缺陷，HotSpot提供了另外⼀种垃圾回收策略，G1（Garbage First）算法，通过参数-XX:+UseG1GC来启⽤，该算法在JDK 7u4版本被正式推出，G1垃圾收集算法主要应⽤在多CPU⼤内存的服务中，在满⾜⾼吞吐量的同时，竟可能的满⾜垃圾回收时的暂停时间，下⾯是官⽅介绍：The Garbage-First (G1) collector is a server-style garbage collector, targeted for multi-processor machines with large memories.It meets garbage collection (GC) pause time goals with a high probability, while achieving high throughput. The G1 garbagecollector is fully supported in Oracle JDK 7 update 4 and later releases. The G1 collector is designed for applications that:Can operate concurrently with applications threads like the CMS collector.Compact free space without lengthy GC induced pause times.Need more predictable GC pause durations.Do not want to sacrifice a lot of throughput performance.Do not require a much larger Java heap.G1采⽤了另外⼀种完全不同的⽅式组织堆内存，堆内存被划分为多个⼤⼩相等的内存块（Region），每个Region是逻辑连续的⼀段内存，G1中提供了三种模式垃圾回收模式，young gc、mixed gc 和 full gc，在不同的条件下被触发。
java⾃动垃圾回收机制前⾔：相⽐C++，java做的⼀⼤改进是将复杂的内存管理抽离出来交给jvm去处理，让码农不再时刻盯着内存泄漏的问题，可以更专注于业务逻辑的开发。
java的GC机制是和其内存模型相关联的，⽽GC的核⼼内存区域是内存中的堆区。
java堆区按对象的存活时间被分为了年轻代（eden区+s0区+s1区）和⽼年代（tentired区），java堆的按代区分其实是为了其垃圾回收的分代收集机制打开了⽅便之门。
java的GC收集器会在不同的分代上使⽤不同的垃圾收集策略。
GC其实主要需要解决两个问题：哪些是垃圾？如何清理垃圾？在解决这两个问题上涉及到下⾯的⽅法论：1.垃圾对象判定⽅法引⽤计数法：在C++的智能指针中使⽤了这种⽅式去做内存的⾃动回收。
即在对象⽣成时维护⼀个对该对象引⽤次数的计数器，对象初次⽣成时计数器值为1，每增加⼀个到该对象的引⽤，计数器加1，每减少⼀个引⽤（如引⽤变量赋值null，或引⽤变量离开作⽤域），计数器减1，计数器为零时，对象内存会被⾃动回收。
该⽅法的问题是存在内存泄漏的隐患，如对象相互引⽤、循环引⽤等情况相互引⽤：public class ReferenceCountingGc {Object instance = null;public static void main(String[] args) {ReferenceCountingGc objA = new ReferenceCountingGc();ReferenceCountingGc objB = new ReferenceCountingGc();objA.instance = objB;objB.instance = objA;objA = null;objB = null;}} 例⼦中两个new出来的对象ReferenceCountingGc由于通过内部的变量instance引⽤着对⽅，两个对象的引⽤计数都为1。
java对象回收方法在Java中，对象的回收主要依靠垃圾回收机制来完成。
垃圾回收是指自动释放不再被使用的内存空间，以便新的对象可以被创建和使用。
Java的垃圾回收机制通过跟踪对象的引用来确定哪些对象是活动的，哪些对象是可以被回收的。
Java对象的回收方法如下：1. 引用计数法（Reference Counting）引用计数法是一种简单的回收方法，在每个对象中维护一个引用计数器，记录对象被引用的次数。
当引用计数器为0时，表示该对象没有被引用，可以被回收。
但是，引用计数法无法解决循环引用的问题，例如两个对象相互引用，导致引用计数器无法为0，内存泄漏就会发生。
2. 可达性分析算法（Reachability Analysis）可达性分析是Java虚拟机使用的主要回收方法。
它通过从一组根对象（如线程栈、静态变量）出发，追踪对象之间的引用关系，标记可达的对象，然后将未标记的对象视为垃圾进行回收。
可达性分析考虑的是对象之间的引用关系，而不是引用计数，因此可以解决循环引用的问题。
3. 标记-清除算法（Mark-Sweep）标记-清除算法是可达性分析的一种实现方式。
首先，通过可达性分析标记出所有活动对象。
然后，将所有未标记的对象清除（回收）。
标记-清除算法会导致内存碎片的产生，在回收后，内存空间可能会被分割成多个不连续的小块，影响后续对象的分配。
标记-整理算法是可达性分析的另一种实现方式。
首先，通过可达性分析标记出所有活动对象。
然后，将所有活动对象向一端移动，将空间释放，并形成一块连续的内存空间。
标记-整理算法能够解决内存碎片的问题，但是会导致对象移动的开销。
5. 复制算法（Copying）复制算法是一种基于分代假设的垃圾回收算法。
它假设大部分对象的生命周期较短，并将堆内存划分为两个区域：From区和To区。
当From 区满时，将存活的对象复制到To区，并清除From区的所有对象。
复制算法具有简单高效的特点，但会浪费一半的内存空间。
垃圾回收机制垃圾回收器GC（Garbage Collection)：JAVA/.NET中的垃圾回收器。
Java是由C++发展来的。
它摈弃了C++中⼀些繁琐容易出错的东西。
其中有⼀条就是这个GC。
⽽C#⼜借鉴了JAVA。
垃圾回收的原因从计算机组成的⾓度来讲，所有的程序都是要驻留在内存中运⾏的。
⽽内存是⼀个限制因素(⼤⼩)。
除此之外，托管堆也有⼤⼩限制。
因为地址空间和存储的限制因素，托管堆要通过垃圾回收机制，来维持它的正常运作，保证对象的分配，尽可能不造成“内存溢出”。
⼤⽩话原理：我们定义变量会申请内存空间来存放变量的值，⽽内存的容量是有限的，当⼀个变量值没有⽤了（称为垃圾），就应该将其占⽤的内存给回收掉。
变量名是访问到变量的唯⼀⽅式，所以当⼀个变量值没有任何关联的变量名时，我们就⽆法访问到该变量了，该变量就是⼀个垃圾，会被程序的垃圾回收机制⾃动回收。
垃圾（Garbage）就是程序需要回收的对象，如果⼀个对象不在被直接或间接地引⽤，那么这个对象就成为了「垃圾」，它占⽤的内存需要及时地释放，否则就会引起「内存泄露」。
有些语⾔需要程序员来⼿动释放内存（回收垃圾），有些语⾔有垃圾回收机制（GC）。
本⽂就来讨论GC实现的三种基本⽅式。
其实这三种⽅式也可以⼤体归为两类：跟踪回收，引⽤计数。
美国IBM的沃森研究中⼼David F.Bacon等⼈发布的「垃圾回收统⼀理论」⼀⽂阐述了⼀个理论：任何垃圾回收的思路，⽆⾮以上两种的组合，其中⼀种的改善和进步，必然伴随着另⼀种的改善和进步。
垃圾回收的基本原理算法思路都是⼀致的：把所有对象组成⼀个集合，或可以理解为树状结构，从树根开始找，只要可以找到的都是活动对象，如果找不到，这个对象就被回收了垃圾回收算法跟踪回收跟踪回收的⽅式独⽴于程序，定期运⾏来检查垃圾，需要较长时间的中断。
标记—清除算法（Mark-Sweep）标记—清除算法是最基础的收集算法，它分为“标记”(mark)和“清除”(sweep)两个阶段：⾸先标记出所需回收的对象，在标记完成后统⼀回收掉所有被标记的对象，它的标记过程其实就是前⾯的可达性分析算法中判定垃圾对象的标记过程。
java中stack和heap的区别，java中的垃圾回收机制#. 在java中有两类内存。
分别称为stack（栈）和heap（堆）。
stack是程序内存空间，因此所有的基本类型和对象的引⽤是存在stack中。
heap是java虚拟机储存对象的，它是⼀个巨⼤的内存，当你创造⼀个对象，java虚拟机把对象放⼊heap中，把创造的对象的地址放⼊stack中。
因此，基本类型、对象的引⽤储存在stack中；对象储存在heap中。
#. java中的垃圾回收机制
当你new⼀个新的对象，java分配必需的内存。
当你⽤完⼀个对象时，java的垃圾回收器为你把内存收回。
垃圾回收以线程的形式在后台运⾏，寻找那些⽆有⽤引⽤（reference）的对象，发现之后便销毁对象，并收回内存。
垃圾回收是在java虚拟机间实现的，它们通常有相同的步骤，⾸先垃圾回收器获得正在运⾏的线程和所有已经加载的类的快照，
然后所有线程中涉及到的对象被标记为最近使⽤的，当可能涉及的对象都被标记的时候，剩下没标记的就被舍弃。
为了帮助虚拟机，我们主动移除⼀些不在需要的对象是⼀个不错的做法，可以通过将引⽤设置为null来实现。
eg：
Text t = new Test();
t.someAction();
//all done
t = null;。
JVM垃圾回收算法及G1回收机制JVM（Java Virtual Machine）是Java程序运行的环境，其中的垃圾回收算法是JVM内存管理的重要组成部分。
垃圾回收算法的作用是自动释放不再使用的内存空间，以提高程序的性能和效率。
其中，G1（Garbage-First）是一种现代化的垃圾回收器，相较于传统的垃圾回收算法具有更高的效率和更低的延迟。
垃圾回收算法的核心思想是通过扫描内存，找出不再被引用的对象，并将其释放。
常见的垃圾回收算法包括标记-清除算法、复制算法、标记-整理算法等。
标记-清除算法是最基础的垃圾回收算法之一、它通过标记所有被引用的对象，然后清除未被标记的对象。
这个算法的优点是可以处理任意的内存分配情况，但是会产生大量的碎片化空间。
复制算法是另一种常见的垃圾回收算法。
它将内存分为两个区域，每次只使用其中一个区域。
当一个区域满了之后，将还存活的对象复制到另一个区域，然后清除当前区域。
这个算法的优点是简单高效，但是会浪费一半的内存空间。
标记-整理算法是标记-清除算法的改进版。
它先标记所有被引用的对象，然后将存活的对象向一端移动，然后清除边界之外的对象。
这个算法的优点是可以减少碎片化空间，但是会有对象移动的开销。
G1是一种基于标记-整理算法的垃圾回收器，它在Java SE 6u14版本中引入。
G1回收机制主要有以下几个特点：首先，G1将堆内存划分为若干个大小相等的区域（Region），每个区域可以是Eden区、Survivor区或Old区。
这种划分方式可以有效地减少碎片化问题，并且可以根据实际情况动态调整区域的大小。
其次，G1采用了增量式的标记算法，在应用程序运行的同时进行垃圾回收操作。
这样可以减少单次垃圾回收的暂停时间，并且将垃圾回收的工作均匀地分布在多个时间片段中，避免长时间的停顿。
再次，G1使用了全局的标记-整理算法。
它通过标记所有被引用的对象，然后将存活的对象向一端移动，并清除边界之外的对象。
Java8的GC垃圾回收Java垃圾回收概况Java GC（Garbage Collection，垃圾回收）机制，是Java与C++/C的主要区别之⼀，作为Java开发者，⼀般不需要专门编写内存回收和垃圾清理代码，对内存泄露和溢出的问题，也不需要像C程序员那样战战兢兢。
这是因为在Java虚拟机中，存在⾃动内存管理和垃圾清扫机制。
概括地说，该机制对JVM中的内存进⾏标记，并确定哪些内存需要回收，根据⼀定的回收策略，⾃动的回收内存，永不停息的保证JVM 中的内存空间，防⽌出现内存泄露和溢出问题。
关于JVM，需要说明⼀下的是，⽬前使⽤最多的Sun公司的JDK中，⾃从1999年的JDK1.2开始直⾄现在仍在⼴泛使⽤的JDK6，其中默认的虚拟机都是HotSpot。
2009年，Oracle收购Sun，加上之前收购的EBA公司，Oracle拥有3⼤虚拟机中的两个：JRockit和HotSpot，Oracle也表明了想要整合两⼤虚拟机的意图，但是⽬前在新发布的JDK8中，默认的虚拟机仍然是HotSpot，因此本⽂中默认介绍的虚拟机都是HotSpot，相关机制也主要是指HotSpot的GC机制。
Java GC机制主要完成3件事：确定哪些内存需要回收确定什么时候需要执⾏GC如何执⾏GC经过这么长时间的发展，Java GC机制已经⽇臻完善，⼏乎可以⾃动的为我们做绝⼤多数的事情。
然⽽，如果我们从事较⼤型的应⽤软件开发，曾经出现过内存优化的需求，就必定要研究Java GC机制。
学习Java GC机制，可以帮助我们在⽇常⼯作中排查各种内存溢出或泄露问题，解决性能瓶颈，达到更⾼的并发量，写出更⾼效的程序。
我们将从4个⽅⾯学习Java GC机制，1，内存是如何分配的；2，如何保证内存不被错误回收（即：哪些内存需要回收）；3，在什么情况下执⾏GC以及执⾏GC的⽅式；4，如何监控和优化GC机制。
内存是如何分配的这⾥所说的内存分配，主要指的是在堆上的分配，⼀般的，对象的内存分配都是在堆上进⾏，但现代技术也⽀持将对象拆成标量类型（标量类型即原⼦类型，表⽰单个值，可以是基本类型或String等），然后在栈上分配，在栈上分配的很少见，我们这⾥不考虑,接下来我们⼀起来了解下内存分区,对我们后⾯学习的有所帮助。
jvm老年代回收机制
JVM（Java虚拟机）是Java程序运行的环境，其内部包含了多个内存区域，其中包括年轻代和老年代。
老年代是用于存放长时间存活的对象的内存区域，在JVM中，老年代的回收机制是非常重要的一部分。
老年代的回收机制主要有两种方式：标记-清除和标记-整理。
在标记-清除机制中，首先会从根对象开始进行标记，标记所有能够被访问到的对象，然后将未被标记的对象进行清除。
这种方式的缺点是会产生大量的碎片化空间，使得内存使用效率降低。
为了解决这个问题，引入了标记-整理机制。
在标记-整理机制中，首先同样进行标记阶段，然后将存活的对象向一端移动，然后清理掉不再使用的对象，最后将存活的对象向另一端移动，使得内存空间变得连续，提高了内存的利用率。
老年代的回收机制是为了解决长时间存活的对象占用大量内存空间的问题。
在JVM中，通过设置阈值来控制对象晋升到老年代的时机。
当新生代中的对象经过多次垃圾回收后仍然存活下来，就会被晋升到老年代。
晋升到老年代的对象会经过一系列的回收过程，包括标记、清除和整理，以保证老年代的内存空间得到有效的回收和利用。
老年代的回收机制在Java程序的性能和稳定性方面起着重要作用。
通过合理设置阈值和调整回收策略，可以提高程序的性能和内存利用率。
同时，老年代的回收机制也需要根据具体的应用场景进行调
整，以满足不同程序的需求。
总结一下，JVM老年代的回收机制是为了解决长时间存活的对象占用大量内存空间的问题。
通过标记-清除和标记-整理两种方式，可以有效地回收老年代的内存空间。
合理设置阈值和调整回收策略，可以提高程序的性能和内存利用率。
垃圾收集GC（Garbage Collection）是Java语言的核心技术之一，之前我们曾专门探讨过Java 7新增的垃圾回收器G1的新特性，但在JVM的内部运行机制上看，Java的垃圾回收原理与机制并未改变。
垃圾收集的目的在于清除不再使用的对象。
GC通过确定对象是否被活动对象引用来确定是否收集该对象。
GC首先要判断该对象是否是时候可以收集。
两种常用的方法是引用计数和对象引用遍历。
引用计数收集器引用计数是垃圾收集器中的早期策略。
在这种方法中，堆中每个对象（不是引用）都有一个引用计数。
当一个对象被创建时，且将该对象分配给一个变量，该变量计数设置为1。
当任何其它变量被赋值为这个对象的引用时，计数加1（a = b,则b引用的对象+1），但当一个对象的某个引用超过了生命周期或者被设置为一个新值时，对象的引用计数减1。
任何引用计数为0的对象可以被当作垃圾收集。
当一个对象被垃圾收集时，它引用的任何对象计数减1。
优点：引用计数收集器可以很快的执行，交织在程序运行中。
对程序不被长时间打断的实时环境比较有利。
缺点：无法检测出循环引用。
如父对象有一个对子对象的引用，子对象反过来引用父对象。
这样，他们的引用计数永远不可能为0.跟踪收集器早期的JVM使用引用计数，现在大多数JVM采用对象引用遍历。
对象引用遍历从一组对象开始，沿着整个对象图上的每条链接，递归确定可到达（reachable）的对象。
如果某对象不能从这些根对象的一个（至少一个）到达，则将它作为垃圾收集。
在对象遍历阶段，GC必须记住哪些对象可以到达，以便删除不可到达的对象，这称为标记（marking）对象。
下一步，GC要删除不可到达的对象。
删除时，有些GC只是简单的扫描堆栈，删除未标记的未标记的对象，并释放它们的内存以生成新的对象，这叫做清除（sweeping）。
这种方法的问题在于内存会分成好多小段，而它们不足以用于新的对象，但是组合起来却很大。
因此，许多GC可以重新组织内存中的对象，并进行压缩（compact），形成可利用的空间。
垃圾回收回收的是无任何引用的对象占据的内存空间而不是对象本身一个对象在运行时，可能会有一些东西与其关连，因此，当对象即将销毁时，有时需要做一些善后工作，可以把这些操作写在finalize()方法（常称之为终止器）。
protected void finalize(){// code here}这个终止器的用途类似于C++里的析构函数，而且都是自动调用的，但是，两者的调用时机不一样，使两者的表现行为有重大区别。
C++的析构函数总是当对象离开作用域时被调用。
这就是说，C++析构函数的调用时机是确定的，且是被应用判知的，但是，JAVA终止器却是在对象被销毁时调用，一旦垃圾收集器准备好释放无用对象占用的存储空间，它首先调用那些对象的finalize()方法，然后才真正回收对象的内在。
我们知道，许多程序设计语言都允许在程序运行期动态地分配内存空间。
分配内存的方式多种多样，取决于该种语言的语法结构。
但不论是哪一种语言的内存分配方式，最后都要返回所分配的内存块的起始地址，即返回一个指针到内存块的首地址。
当已经分配的内存空间不再需要时，换句话说当指向该内存块的句柄超出了使用范围的时候，该程序或其运行环境就应该回收该内存空间，以节省宝贵的内存资源。
在C，C++或其他程序设计语言中，无论是对象还是动态配置的资源或内存，都必须由程序员自行声明产生和回收，否则其中的资源将消耗，造成资源的浪费甚至死机。
但手工回收内存往往是一项复杂而艰巨的工作。
因为要预先确定占用的内存空间是否应该被回收是非常困难的！如果一段程序不能回收内存空间，而且在程序运行时系统中又没有了可以分配的内存空间时，这段程序就只能崩溃。
通常，我们把分配出去后，却无法回收的内存空间称为"内存渗漏体（Memory Leaks）"。
以上这种程序设计的潜在危险性在Java这样以严谨、安全著称的语言中是不允许的。
但是Java语言既不能限制程序员编写程序的自由性，又不能把声明对象的部分去除（否则就不是面向对象的程序语言了），那么最好的解决办法就是从Java程序语言本身的特性入手。
于是，Java技术提供了一个系统级的线程（Thread），即垃圾收集器线程（Garbage Collection Thread），来跟踪每一块分配出去的内存空间，当Java 虚拟机（Java Virtual Machine）处于空闲循环时，垃圾收集器线程会自动检查每一快分配出去的内存空间，然后自动回收每一快可以回收的无用的内存块。
垃圾收集器线程是一种低优先级的线程，在一个Java程序的生命周期中，它只有在内存空闲的时候才有机会运行。
它有效地防止了内存渗漏体的出现，并极大可能地节省了宝贵的内存资源。
但是，通过Java虚拟机来执行垃圾收集器的方案可以是多种多样的。
下面介绍垃圾收集器的特点和它的执行机制：垃圾收集器系统有自己的一套方案来判断哪个内存块是应该被回收的，哪个是不符合要求暂不回收的。
垃圾收集器在一个Java程序中的执行是自动的，不能强制执行，即使程序员能明确地判断出有一块内存已经无用了，是应该回收的，程序员也不能强制垃圾收集器回收该内存块。
程序员唯一能做的就是通过调用System. gc 方法来"建议"执行垃圾收集器，但其是否可以执行，什么时候执行却都是不可知的。
这也是垃圾收集器的最主要的缺点。
当然相对于它给程序员带来的巨大方便性而言，这个缺点是瑕不掩瑜的。
垃圾收集器的主要特点有：1．垃圾收集器的工作目标是回收已经无用的对象的内存空间，从而避免内存渗漏体的产生，节省内存资源，避免程序代码的崩溃。
2．垃圾收集器判断一个对象的内存空间是否无用的标准是：如果该对象不能再被程序中任何一个"活动的部分"所引用，此时我们就说，该对象的内存空间已经无用。
所谓"活动的部分"，是指程序中某部分参与程序的调用，正在执行过程中，尚未执行完毕。
3．垃圾收集器线程虽然是作为低优先级的线程运行，但在系统可用内存量过低的时候，它可能会突发地执行来挽救内存资源。
当然其执行与否也是不可预知的。
4．垃圾收集器不可以被强制执行，但程序员可以通过调用System. gc方法来建议执行垃圾收集器。
5．不能保证一个无用的对象一定会被垃圾收集器收集，也不能保证垃圾收集器在一段Java 语言代码中一定会执行。
因此在程序执行过程中被分配出去的内存空间可能会一直保留到该程序执行完毕，除非该空间被重新分配或被其他方法回收。
由此可见，完全彻底地根绝内存渗漏体的产生也是不可能的。
但是请不要忘记，Java的垃圾收集器毕竟使程序员从手工回收内存空间的繁重工作中解脱了出来。
设想一个程序员要用C或C++来编写一段10万行语句的代码，那么他一定会充分体会到Java的垃圾收集器的优点！6．同样没有办法预知在一组均符合垃圾收集器收集标准的对象中，哪一个会被首先收集。
7．循环引用对象不会影响其被垃圾收集器收集。
8．可以通过将对象的引用变量（reference variables，即句柄handles）初始化为null值，来暗示垃圾收集器来收集该对象。
但此时，如果该对象连接有事件监听器（典型的AWT组件），那它还是不可以被收集。
所以在设一个引用变量为null值之前，应注意该引用变量指向的对象是否被监听，若有，要首先除去监听器，然后才可以赋空值。
9．每一个对象都有一个finalize( )方法，这个方法是从Object类继承来的。
10．finalize( )方法用来回收内存以外的系统资源，就像是文件处理器和网络连接器。
该方法的调用顺序和用来调用该方法的对象的创建顺序是无关的。
换句话说，书写程序时该方法的顺序和方法的实际调用顺序是不相干的。
请注意这只是finalize( )方法的特点。
11．每个对象只能调用finalize( )方法一次。
如果在finalize( )方法执行时产生异常（exception），则该对象仍可以被垃圾收集器收集。
12．垃圾收集器跟踪每一个对象，收集那些不可到达的对象（即该对象没有被程序的任何"活的部分"所调用），回收其占有的内存空间。
但在进行垃圾收集的时候，垃圾收集器会调用finalize( )方法，通过让其他对象知道它的存在，而使不可到达的对象再次"复苏"为可到达的对象。
既然每个对象只能调用一次finalize( )方法，所以每个对象也只可能"复苏"一次。
13．finalize( )方法可以明确地被调用，但它却不能进行垃圾收集。
14．finalize( )方法可以被重载（overload），但只有具备初始的finalize( )方法特点的方法才可以被垃圾收集器调用。
15．子类的finalize( )方法可以明确地调用父类的finalize( )方法，作为该子类对象的最后一次适当的操作。
但Java编译器却不认为这是一次覆盖操作（overriding），所以也不会对其调用进行检查。
16．当finalize( )方法尚未被调用时，System. runFinalization( )方法可以用来调用finalize( )方法，并实现相同的效果，对无用对象进行垃圾收集。
17．当一个方法执行完毕，其中的局部变量就会超出使用范围，此时可以被当作垃圾收集，但以后每当该方法再次被调用时，其中的局部变量便会被重新创建。
18．Java语言使用了一种"标记交换区的垃圾收集算法"。
该算法会遍历程序中每一个对象的句柄，为被引用的对象做标记，然后回收尚未做标记的对象。
所谓遍历可以简单地理解为"检查每一个"。
19．Java语言允许程序员为任何方法添加finalize( )方法，该方法会在垃圾收集器交换回收对象之前被调用。
但不要过分依赖该方法对系统资源进行回收和再利用，因为该方法调用后的执行结果是不可预知的。
通过以上对垃圾收集器特点的了解，你应该可以明确垃圾收集器的作用，和垃圾收集器判断一块内存空间是否无用的标准。
简单地说，当你为一个对象赋值为null并且重新定向了该对象的引用者，此时该对象就符合垃圾收集器的收集标准。
判断一个对象是否符合垃圾收集器的收集标准，这是SUN公司程序员认证考试中垃圾收集器部分的重要考点（可以说，这是唯一的考点）。
所以，考生在一段给定的代码中，应该能够判断出哪个对象符合垃圾收集器收集的标准，哪个不符合。
下面结合几种认证考试中可能出现的题型来具体讲解：Object obj = new Object ( ) ;我们知道，obj为Object的一个句柄。
当出现new关键字时，就给新建的对象分配内存空间，而obj的值就是新分配的内存空间的首地址，即该对象的值(请特别注意，对象的值和对象的内容是不同含义的两个概念：对象的值就是指其内存块的首地址，即对象的句柄；而对象的内容则是其具体的内存块)。
此时如果有obj = null；则obj指向的内存块此时就无用了，因为下面再没有调用该变量了。
请再看以下三种认证考试时可能出现的题型：程序段1：1．fobj = new Object ( ) ;2．fobj. Method ( ) ;3．fobj = new Object ( ) ;4．fobj. Method ( ) ;问：这段代码中，第几行的fobj 符合垃圾收集器的收集标准？答：第3行。
因为第3行的fobj被赋了新值，产生了一个新的对象，即换了一块新的内存空间，也相当于为第1行中的fobj赋了null值。
这种类型的题在认证0考试中是最简单的。
程序段2：1．Object sobj = new Object ( ) ;2．Object sobj = null ;3．Object sobj = new Object ( ) ;4．sobj = new Object ( ) ;问：这段代码中，第几行的内存空间符合垃圾收集器的收集标准？答：第1行和第3行。
因为第2行为sobj赋值为null，所以在此第1行的sobj符合垃圾收集器的收集标准。
而第4行相当于为sobj赋值为null，所以在此第3行的sobj也符合垃圾收集器的收集标准。
如果有一个对象的句柄a，且你把a作为某个构造器的参数，即new Constructor ( a )的时候，即使你给a赋值为null，a也不符合垃圾收集器的收集标准。
直到由上面构造器构造的新对象被赋空值时，a才可以被垃圾收集器收集。
程序段3：1．Object aobj = new Object ( ) ;2．Object bobj = new Object ( ) ;3．Object cobj = new Object ( ) ;4．aobj = bobj;5．aobj = cobj;6．cobj = null;7．aobj = null;问：这段代码中，第几行的内存空间符合垃圾收集器的收集标准？答：第7行。
