Java垃圾回收

垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收
答：垃圾回收机制通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清理。对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。可以。程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。

垃圾回收机制的优点及工作原理

 答： JAVA的一个重大特点就是引进了垃圾回收机制，从而使C++程序员最头疼的内存管理问题迎刃而解，它使得Java程序员在编写程序的时候不用考虑内存管理。由于有了垃圾回收机制，Java中的对象不再有“作用域”的概念，只有对象的引用才有“作用域”.
     优点：垃圾回收机制可以有效的防止内存泄漏，有效的使用可以使用的内存。

=================================================================================================================================

1 垃圾回收原因：

当对象被创建时，就会在Java虚拟机的堆区中拥有一块内存，在Java虚拟机的生命周期中，Java程序会陆续地创建无数个对象，假如所有的对象都永久占有内存，那么内存有可能很快被消耗光，最后引发内存空间不足的错误。因此必须采取一种措施来及时回收那些无用对象的内存，以保证内存可以被重复利用。

在一些传统的编程语言（如C语言）中，回收内存的任务是由程序本身负责的。程序可以显式地为自己的变量分配一块内存空间，当这些变量不再有用时，程序必须显式地释放变量所占用的内存。把直接操纵内存的权利赋给程序，尽管给程序带来了很多灵活性，但是也会导致以下弊端：

 程序员有可能因为粗心大意，忘记及时释放无用变量的内存，从而影响程序的健壮性。

 程序员有可能错误地释放核心类库所占用的内存，导致系统崩溃。

在Java语言中，内存回收的任务由Java虚拟机来担当，而不是由Java程序来负责。在程序的运行时环境中， Java虚拟机提供了一个系统级的垃圾回收器线程，它负责自动回收那些无用对象所占用的内存，这种内存回收的过程被称为垃圾回收（Garbage Collection）。

垃圾回收具有以下优点：

 把程序员从复杂的内存追踪、监测和释放等工作中解放出来，减轻程序员进行内存管理的负担。

 防止系统内存被非法释放，从而使系统更加健壮和稳定。

垃圾回收具有以下特点：

只有当对象不再被程序中的任何引用变量引用时，它的内存才可能被回收。

 程序无法迫使垃圾回收器立即执行垃圾回收操作。

 当垃圾回收器将要回收无用对象的内存时，先调用该对象的finalize()方法，该方法有可能使对象复活，导致垃圾回收器取消回收该对象的内存。

2 原理：

 

在Java虚拟机的垃圾回收器看来，堆区中的每个对象都可能处于以下三个状态之一。

 可触及状态：当一个对象（假定为Sample对象）被创建后，只要程序中还有引用变量引用它，那么它就始终处于可触及状态。

 可复活状态：当程序不再有任何引用变量引用Sample对象时，它就进入可复活状态。在这个状态中，垃圾回收器会准备释放它占用的内存，在释放之前，会调用它及其他处于可复活状态的对象的finalize()方法，这些finalize()方法有可能使Sample 对象重新转到可触及状态。

 不可触及状态：当Java虚拟机执行完所有可复活对象的finalize()方法后，假如这些方法都没有使Sample对象转到可触及状态，那么Sample对象就进入不可触及状态。只有当对象处于不可触及状态时，垃圾回收器才会真正回收它占用的内存。

图11-6显示了对象的状态转换过程。

以下method()方法先后创建了两个Integer对象。

public static void method(){

Integer a1=new Integer(10); //①

Integer a2=new Integer(20); //②

a1=a2; //③

}

public static void main(String args[]){

method();

System.out.println("End");

}

图11-7 两个Integer对象的状态

当程序执行完第③行时，取值为10的Integer对象不再被任何变量引用，因此转到可复活状态，取值为20的Integer对象处于可触及状态，它被变量a1和a2引用，参见图11-7。

当程序退出method()方法并返回到main()方法时，在method()方法中定义的局部变量a1和a2都将结束生命周期，堆区中取值为20的Integer对象也将转到可复活状态。

3 回收：

当一个对象处于可复活状态时，垃圾回收线程何时执行它的finalize()方法，何时使它转到不可触及状态，何时回收它占用的内存，这对于程序来说都是透明的。程序只能决定一个对象何时不再被任何引用变量引用，使得它成为可以被回收的垃圾。这就像每个居民只要把无用的物品（相当于无用的对象）放在指定的地方，清洁工人就会把它收拾走一样，但是，垃圾什么时候被收走，居民是不知道的，也无须对此了解。

站在程序的角度，如果一个对象不处于可触及状态，就可以称它为无用对象，程序不会持有无用对象的引用，不会再使用它，这样的对象可以被垃圾回收器回收。站在程序的角度，一个对象的生命周期从被创建开始，到不再被任何变量引用（即变为无用对象）结束。在本书其他章节提到对象的生命周期，如果未做特别说明，都沿用这个含义。

垃圾回收器作为低优先级线程独立运行。在任何时候，程序都无法迫使垃圾回收器立即执行垃圾回收操作。在程序中可以调用System.gc()或者Runtime.gc()方法提示垃圾回收器尽快执行垃圾回收操作，但是这也不能保证调用完该方法后，垃圾回收线程就立即执行回收操作，而且不能保证垃圾回收线程一定会执行这一操作。这就像当小区内的垃圾成堆时，居民无法立即把环保局的清洁工人招来，令其马上清除垃圾一样，居民所能做的是给环保局打电话，催促他们尽快来处理垃圾。这种做法仅仅提高了清洁工人尽快来处理垃圾的可能性，但仍然存在清洁工人过了很久才来或者永远不来清除垃圾的可能性。

4 垃圾收集的算法分析：

Java语言规范没有明确地说明JVM使用哪种垃圾回收算法，但是任何一种垃圾收集算法一般要做2件基本的事情：（1）发现无用信息对象；（2）回收被无用对象占用的内存空间，使该空间可被程序再次使用。

　　大多数垃圾回收算法使用了根集(root set)这个概念；所谓根集就量正在执行的Java程序可以访问的引用变量的集合(包括局部变量、参数、类变量)，程序可以使用引用变量访问对象的属性和调用对象的方法。垃圾收集首选需要确定从根开始哪些是可达的和哪些是不可达的，从根集可达的对象都是活动对象，它们不能作为垃圾被回收，这也包括从根集间接可达的对象。而根集通过任意路径不可达的对象符合垃圾收集的条件，应该被回收。下面介绍几个常用的算法。

　　1、引用计数法(Reference Counting Collector)

　　引用计数法是唯一没有使用根集的垃圾回收得法，该算法使用引用计数器来区分存活对象和不再使用的对象。一般来说，堆中的每个对象对应一个引用计数器。当每一次创建一个对象并赋给一个变量时，引用计数器置为1。当对象被赋给任意变量时，引用计数器每次加1。当对象出了作用域后(该对象丢弃不再使用)，引用计数器减1，一旦引用计数器为0，对象就满足了垃圾收集的条件。

　　基于引用计数器的垃圾收集器运行较快，不会长时间中断程序执行，适宜地必须 实时运行的程序。但引用计数器增加了程序执行的开销，因为每次对象赋给新的变量 ，计数器加1，而每次现有对象出了作用域生，计数器减1。

　　2、tracing算法(Tracing Collector)

　　tracing算法是为了解决引用计数法的问题而提出，它使用了根集的概念。基于tracing算法的垃圾收集器从根集开始扫描，识别出哪些对象可达，哪些对象不可达，并用某种方式标记可达对象，例如对每个可达对象设置一个或多个位。在扫描识别过程中，基于tracing算法的垃圾收集也称为标记和清除(mark-and-sweep)垃圾收集器.

　　3、compacting算法(Compacting Collector)

　　为了解决堆碎片问题，基于tracing的垃圾回收吸收了Compacting算法的思想，在清除的过程中，算法将所有的对象移到堆的一端，堆的另一端就变成了一个相邻的空闲内存区，收集器会对它移动的所有对象的所有引用进行更新，使得这些引用 在新的位置能识别原来 的对象。在基于Compacting算法的收集器的实现中，一般增加句柄和句柄表。

　　4、coping算法(Coping Collector)

　　该算法的提出是为了克服句柄的开销和解决堆碎片的垃圾回收。它开始时把堆分成 一个对象 面和多个空闲面， 程序从对象面为对象分配空间，当对象满了，基于coping算法的垃圾 收集就从根集中扫描活动对象，并将每个 活动对象复制到空闲面(使得活动对象所占的内存之间没有空闲洞)，这样空闲面变成了对象面，原来的对象面变成了空闲面，程序会在新的对象面中分配内存。

　　一种典型的基于coping算法的垃圾回收是stop-and-copy算法，它将堆分成对象面和空闲区域面，在对象面与空闲区域面的切换过程中，程序暂停执行。

　　5、generation算法(Generational Collector)

　　stop-and-copy垃圾收集器的一个缺陷是收集器必须复制所有的活动对象，这增加了程序等待时间，这是coping算法低效的原因。在程序设计中有这样的规律：多数对象存在的时间比较短，少数的存在时间比较长。因此，generation算法将堆分成两个或多个，每个子堆作为对象的一代(generation)。由于多数对象存在的时间比较短，随着程序丢弃不使用的对象，垃圾收集器将从最年轻的子堆中收集这些对象。在分代式的垃圾收集器运行后，上次运行存活下来的对象移到下一最高代的子堆中，由于老一代的子堆不会经常被回收，因而节省了时间。

　　6、adaptive算法(Adaptive Collector)

　　在特定的情况下，一些垃圾收集算法会优于其它算法。基于Adaptive算法的垃圾收集器就是监控当前堆的使用情况，并将选择适当算法的垃圾收集器。

关于垃圾收集的几点补充

　　经过上述的说明，可以发现垃圾回收有以下的几个特点：

　　（1）垃圾收集发生的不可预知性：由于实现了不同的垃圾收集算法和采用了不同的收集机制，所以它有可能是定时发生，有可能是当出现系统空闲CPU资源时发生，也有可能是和原始的垃圾收集一样，等到内存消耗出现极限时发生，这与垃圾收集器的选择和具体的设置都有关系。

　　（2）垃圾收集的精确性：主要包括2 个方面：（a）垃圾收集器能够精确标记活着的对象；（b）垃圾收集器能够精确地定位对象之间的引用关系。前者是完全地回收所有废弃对象的前提，否则就可能造成内存泄漏。而后者则是实现归并和复制等算法的必要条件。所有不可达对象都能够可靠地得到回收，所有对象都能够重新分配，允许对象的复制和对象内存的缩并，这样就有效地防止内存的支离破碎。 （3）现在有许多种不同的垃圾收集器，每种有其算法且其表现各异，既有当垃圾收集开始时就停止应用程序的运行，又有当垃圾收集开始时也允许应用程序的线程运行，还有在同一时间垃圾收集多线程运行。

　　（4）垃圾收集的实现和具体的JVM 以及JVM的内存模型有非常紧密的关系。不同的JVM 可能采用不同的垃圾收集，而JVM 的内存模型决定着该JVM可以采用哪些类型垃圾收集。现在，HotSpot 系列JVM中的内存系统都采用先进的面向对象的框架设计，这使得该系列JVM都可以采用最先进的垃圾收集。

　　（5）随着技术的发展，现代垃圾收集技术提供许多可选的垃圾收集器，而且在配置每种收集器的时候又可以设置不同的参数，这就使得根据不同的应用环境获得最优的应用性能成为可能。

　　针对以上特点，我们在使用的时候要注意：

　　（1）不要试图去假定垃圾收集发生的时间，这一切都是未知的。比如，方法中的一个临时对象在方法调用完毕后就变成了无用对象，这个时候它的内存就可以被释放。

　　（2）Java中提供了一些和垃圾收集打交道的类，而且提供了一种强行执行垃圾收集的方法--调用System.gc()，但这同样是个不确定的方法。Java 中并不保证每次调用该方法就一定能够启动垃圾收集，它只不过会向JVM发出这样一个申请，到底是否真正执行垃圾收集，一切都是个未知数。

　　（3）挑选适合自己的垃圾收集器。一般来说，如果系统没有特殊和苛刻的性能要求，可以采用JVM的缺省选项。否则可以考虑使用有针对性的垃圾收集器，比如增量收集器就比较适合实时性要求较高的系统之中。系统具有较高的配置，有比较多的闲置资源，可以考虑使用并行标记/清除收集器。

　　（4）关键的也是难把握的问题是内存泄漏。良好的编程习惯和严谨的编程态度永远是最重要的，不要让自己的一个小错误导致内存出现大漏洞。

　　（5）尽早释放无用对象的引用。大多数程序员在使用临时变量的时候，都是让引用变量在退出活动域(scope)后，自动设置为null，暗示垃圾收集器来收集该对象，还必须注意该引用的对象是否被监听，如果有，则要去掉监听器，然后再赋空值。

 注：

一、谁在做Garbage Collection?

　　一种流行的说法:在C++里，是系统在做垃圾回收;而在Java里，是Java自身在做。

　　在C++里，释放内存是手动处理的，要用delete运算符来释放分配的内存。这是流行的说法。确切地说，是应用认为不需要某实体时，就需用delete告诉系统，可以回收这块空间了。这个要求，对编码者来说，是件很麻烦、很难做到的事。随便上哪个BBS，在C/C++版块里总是有一大堆关于内存泄漏的话题。

　　Java采用一种不同的，很方便的方法:Garbage Collection.垃圾回收机制放在JVM里。JVM完全负责垃圾回收事宜，应用只在需要时申请空间，而在抛弃对象时不必关心空间回收问题。

　　二、对象在啥时被丢弃?

　　在C++里，当对象离开其作用域时，该对象即被应用抛弃。

　　是对象的生命期不再与其作用域有关，而仅仅与引用有关。

　　Java的垃圾回收机制一般包含近十种算法。对这些算法中的多数，我们不必予以关心。只有其中最简单的一个:引用计数法，与编码有关。

　　一个对象，可以有一个或多个引用变量指向它。当一个对象不再有任何一个引用变量指向它时，这个对象就被应用抛弃了。或者说，这个对象可以被垃圾回收机制回收了。

　　这就是说，当不存在对某对象的任何引用时，就意味着，应用告诉JVM:我不要这个对象，你可以回收了。

　　JVM的垃圾回收机制对堆空间做实时检测。当发现某对象的引用计数为0时，就将该对象列入待回收列表中。但是，并不是马上予以销毁。

　　三、丢弃就被回收?

　　该对象被认定为没有存在的必要了，那么它所占用的内存就可以被释放。被回收的内存可以用于后续的再分配。

　　但是，并不是对象被抛弃后当即被回收的。JVM进程做空间回收有较大的系统开销。如果每当某应用进程丢弃一个对象，就立即回收它的空间，势必会使整个系统的运转效率非常低下。

　　前面说过，JVM的垃圾回收机制有多个算法。除了引用计数法是用来判断对象是否已被抛弃外，其它算法是用来确定何时及如何做回收。JVM的垃圾回收机制要在时间和空间之间做个平衡。

　　因此，为了提高系统效率，垃圾回收器通常只在满足两个条件时才运行:即有对象要回收且系统需要回收。切记垃圾回收要占用时间，因此，Java运行时系统只在需要的时候才使用它。因此你无法知道垃圾回收发生的精确时间。

　　四、没有引用变量指向的对象有用吗?

　　前面说了，没挂上引用变量的对象是被应用丢弃的，这意味着，它在堆空间里是个垃圾，随时可能被JVM回收。

　　不过，这里有个不是例外的例外。对于一次性使用的对象(有些书称之为临时对象)，可以不用引用变量指向它。举个最简单也最常见的例子:

　　System.out.println(“I am Java!”);

　　就是创建了一个字符串对象后，直接传递给println()方法。

　　五、应用能干预垃圾回收吗?

　　许多人对Java的垃圾回收不放心，希望在应用代码里控制JVM的垃圾回收运作。这是不可能的事。对垃圾回收机制来说，应用只有两个途径发消息给JVM.第一个前面已经说了，就是将指向某对象的所有引用变量全部移走。这就相当于向JVM发了一个消息:这个对象不要了。第二个是调用库方法System.gc()，多数书里说调用它让Java做垃圾回收。

　　第一个是一个告知，而调用System.gc()也仅仅是一个请求。JVM接受这个消息后，并不是立即做垃圾回收，而只是对几个垃圾回收算法做了加权，使垃圾回收操作容易发生，或提早发生，或回收较多而已。

　　希望JVM及时回收垃圾，是一种需求。其实，还有相反的一种需要:在某段时间内最好不要回收垃圾。要求运行速度最快的实时系统，特别是嵌入式系统，往往希望如此。

　　Java的垃圾回收机制是为所有Java应用进程服务的，而不是为某个特定的进程服务的。因此，任何一个进程都不能命令垃圾回收机制做什么、怎么做或做多少。

　　六、对象被回收时要做的事

　　一个对象在运行时，可能会有一些东西与其关连。因此，当对象即将被销毁时，有时需要做一些善后工作。可以把这些操作写在finalize()方法(常称之为终止器)里。

　　protected void finalize()

　　{

　　// finalization code here

　　}

　　这个终止器的用途类似于C++里的析构函数，而且都是自动调用的。但是，两者的调用时机不一样，使两者的表现行为有重大区别。C++的析构函数总是当对象离开作用域时被调用。这就是说，C++析构函数的调用时机是确定的，且是可被应用判知的。但是，Java终止器却是在对象被销毁时。由上所知，被丢弃的对象何时被销毁，应用是无法获知的。而且，对于大多数场合，被丢弃对象在应用终止后仍未销毁。

　　在编码时，考虑到这一点。譬如，某对象在运作时打开了某个文件，在对象被丢弃时不关闭它，而是把文件关闭语句写在终止器里。这样做对文件操作会造成问题。如果文件是独占打开的，则其它对象将无法访问这个文件。如果文件是共享打开的，则另一访问该文件的对象直至应用终结仍不能读到被丢弃对象写入该文件的新内容。

　　至少对于文件操作，编码者应认清Java终止器与C++析构函数之间的差异。

　　那么，当应用终止，会不会执行应用中的所有finalize()呢?据Bruce Eckel在Thinking in Java里的观点:“到程序结束的时候，并非所有收尾模块都会得到调用”。这还仅仅是指应用正常终止的场合，非正常终止呢?

　　因此，哪些收尾操作可以放在finalize()里，是需要酌酎的。