Java基础---垃圾回收机制

前言

Java的堆是一个运行时数据区，类的实例(对象)从中分配空间。

Java虚拟机(JVM)的堆中储存着正在运行的应用程序所建立的所有对象，这些对象通过new、newarray、anewarray和multianewarray等指令建立，但是它们不需要程序代码来显式地释放。

垃圾回收（garbage collection）是一种动态存储管理技术，它自动地释放不再被程序引用的对象，按照特定的垃圾收集算法来实现资源自动回收的功能。

 

1. 垃圾回收的意义

---

 

在C++中，对象所占的内存在程序结束运行之前一直被占用，在明确释放之前不能分配给其它对象；而在Java中，当没有对象引用指向原先分配给某个对象的内存时，该内存便成为垃圾。

而在Java中，当没有对象引用指向原先分配给某个对象的内存时，该内存便成为垃圾。JVM的一个系统级线程会自动释放该内存块。

当一个对象不再被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用。

 

事实上，除了释放没用的对象，垃圾收集也可以清除内存记录碎片。

垃圾收集的一个潜在的缺点是它的开销影响程序性能。Java虚拟机必须追踪运行程序中有用的对象，而且最终释放没用的对象。

 

2. 垃圾收集的算法分析

---

 

Java语言规范没有明确地说明JVM使用哪种垃圾回收算法，但是任何一种垃圾收集算法一般要做2件基本的事情：

（1）发现无用信息对象

早期的JVM使用引用计数，现在大多数JVM采用对象引用遍历。对象引用遍历从一组对象开始，沿着整个对象图上的每条链接，递归确定可到达（reachable）的对象。如果某对象不能从这些根对象的一个（至少一个）到达，则将它作为垃圾收集。在对象遍历阶段，GC必须记住哪些对象可以到达，以便删除不可到达的对象，这称为标记（marking）对象。

大多数垃圾回收算法使用了根集(root set)这个概念：

所谓根集就是正在执行的Java程序可以访问的引用变量的集合(包括局部变量、参数、类变量)，程序可以使用引用变量访问对象的属性和调用对象的方法。

 

（2）回收被无用对象占用的内存空间，使该空间可被程序再次使用

下一步，GC要删除不可到达的对象。

删除时，有些GC只是简单的扫描堆栈，删除未标记的未标记的对象，并释放它们的内存以生成新的对象，这叫做清除（sweeping）。

这种方法的问题在于内存会分成好多小段，而它们不足以用于新的对象，但是组合起来却很大

因此，许多GC可以重新组织内存中的对象，并进行压缩（compact），形成可利用的空间。

 

① 引用计数法

引用计数法是唯一没有使用根集的垃圾回收的法，该算法使用引用计数器来区分存活对象和不再使用的对象。

一般来说，堆中的每个对象对应一个引用计数器。

当每一次创建一个对象并赋给一个变量时，引用计数器置为1。当对象被赋给任意变量时，引用计数器每次加1当对象出了作用域后(该对象丢弃不再使用)，引用计数器减1，一旦引用计数器为0，对象就满足了垃圾收集的条件。

优点：引用计数收集器可以很快的执行，交织在程序运行中。对程序不被长时间打断的实时环境比较有利。

缺点： 无法检测出循环引用。如父对象有一个对子对象的引用，子对象反过来引用父对象。这样，他们的引用计数永远不可能为0

 

② 标记－清除法

这种收集器首先遍历对象图并标记可到达的对象，然后扫描堆栈以寻找未标记对象并释放它们的内存。

优点：优点在于，当大块内存释放时，有利于整个内存的重分配

缺点：这种收集器一般使用单线程工作并停止其他操作。并且，由于它只是清除了那些未标记的对象，而并没有对标记对象进行压缩，导致会产生大量内存碎片，从而浪费内存。

 

 

③ 标记－压缩法

有时也叫标记－清除－压缩收集器，与标记－清除收集器有相同的标记阶段。

在第二阶段，则把标记对象复制到堆栈的新域中以便压缩堆栈。

这种收集器也停止其他操作。

 

④ 复制法

这种收集器将堆栈分为两个域，常称为半空间。

每次仅使用一半的空间，JVM生成的新对象则放在另一半空间中。

GC运行时，它把可到达对象复制到另一半空间，从而压缩了堆栈。

优点：这种方法适用于短生存期的对象，持续复制长生存期的对象则导致效率降低。

缺点：并且对于指定大小堆来说，需要两倍大小的内存，因为任何时候都只使用其中的一半。

 

⑤ 增量法

增量收集器把堆栈分为多个域，每次仅从一个域收集垃圾，也可理解为把堆栈分成一小块一小块，每次仅对某一个块进行垃圾收集。

这会造成较小的应用程序中断时间，使得用户一般不能觉察到垃圾收集器正在工作。

 

⑥ 分代法

复制收集器的缺点是：每次收集时，所有的标记对象都要被拷贝，从而导致一些生命周期很长的对象被来回拷贝多次，消耗大量的时间。

而分代收集器则可解决这个问题，分代收集器把堆栈分为两个或多个域，用以存放不同寿命的对象。

JVM生成的新对象一般放在其中的某个域中。

过一段时间，继续存在的对象(非短命对象)将获得使用期并转入更长寿命的域中。

分代收集器对不同的域使用不同的算法以优化性能。

 

⑦ 并行法

并行收集器使用某种传统的算法并使用多线程并行的执行它们的工作。

在多CPU机器上使用多线程技术可以显著的提高java应用程序的可扩展性。

 

3. 使用垃圾回收机制的注意事项：

---

 

（1）每个对象只能调用finalize( )方法一次。如果在finalize( )方法执行时产生异常（exception），则该对象仍可以被垃圾收集器收集。

（2）在进行垃圾收集的时候，垃圾收集器会调用该对象的finalize( )方法（如果有）。如果在finalize()方法中，又使得该对象被程序引用(俗称复活了)，则该对象就变成了可触及的对象，暂时不会被垃圾收集了。但是由于每个对象只能调用一次finalize( )方法，所以每个对象也只可能 "复活 "一次。

（3）垃圾收集器不可以被强制执行，但程序员可以通过调研System.gc方法来建议执行垃圾收集。记住，只是建议。不要试图去假定垃圾收集发生的时间，这一切都是未知的。

（4）垃圾收集的实现和具体的JVM 以及JVM的内存模型有非常紧密的关系。不同的JVM 可能采用不同的垃圾收集，而JVM 的内存模型决定着该JVM可以采用哪些类型垃圾收集。

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

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

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

（7）java垃圾回收，主要是靠一个低优先级的进程负责回收，注意，不是后台的进程

（8）没有办法预知在一组均符合垃圾收集器收集标准的对象中，哪一个会被首先收集。

（9）循环引用对象不会影响其被垃圾收集器收集。

（10）可以通过将对象的引用变量（reference variables，即句柄handles）初始化为null值，来暗示垃圾收集器来收集该对象。但此时，如果该对象连接有事件监听器（典型的 AWT组件），那它还是不可以被收集。所以在设一个引用变量为null值之前，应注意该引用变量指向的对象是否被监听，若有，要首先除去监听器，然后才可以赋空值。

 

 

 

 

4. JVM分代垃圾回收策略的基础概念：

---

由于不同对象的生命周期不一样，因此在JVM的垃圾回收策略中有分代这一策略。

为什么要分代

分代的垃圾回收策略，是基于这样一个事实：不同的对象的生命周期是不一样的。因此，不同生命周期的对象可以采取不同的收集方式，以便提高回收效率。

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

试想，在不进行对象存活时间区分的情况下，每次垃圾回收都是对整个堆空间进行回收，花费时间相对会长，同时，因为每次回收都需要遍历所有存活对象，但实际上，对于生命周期长的对象而言，这种遍历是没有效果的，因为可能进行了很多次遍历，但是他们依旧存在。因此，分代垃圾回收采用分治的思想，进行代的划分，把不同生命周期的对象放在不同代上，不同代上采用最适合它的垃圾回收方式进行回收。

 

如何分代

虚拟机中的共划分为三个代：年轻代（Young Generation）、年老代（Old Generation）和持久代（Permanent Generation）。其中持久代主要存放的是Java类的类信息，与垃圾收集要收集的Java对象关系不大。年轻代和年老代的划分是对垃圾收集影响比较大的。

年轻代:

所有新生成的对象首先都是放在年轻代的。年轻代的目标就是尽可能快速的收集掉那些生命周期短的对象。年轻代分三个区。一个Eden区，两个Survivor区(一般而言)。大部分对象在Eden区中生成。当Eden区满时，还存活的对象将被复制到Survivor区（两个中的一个），当这个Survivor区满时，此区的存活对象将被复制到另外一个Survivor区，当这个Survivor去也满了的时候，从第一个Survivor区复制过来的并且此时还存活的对象，将被复制“年老区(Tenured)”。需要注意，Survivor的两个区是对称的，没先后关系，所以同一个区中可能同时存在从Eden复制过来 对象，和从前一个Survivor复制过来的对象，而复制到年老区的只有从第一个Survivor去过来的对象。而且，Survivor区总有一个是空的。同时，根据程序需要，Survivor区是可以配置为多个的（多于两个），这样可以增加对象在年轻代中的存在时间，减少被放到年老代的可能。

年老代:

在年轻代中经历了N次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。

持久代:

用于存放静态文件，如今Java类、方法等。持久代对垃圾回收没有显著影响，但是有些应用可能动态生成或者调用一些class，例如Hibernate等，在这种时候需要设置一个比较大的持久代空间来存放这些运行过程中新增的类。持久代大小通过-XX:MaxPermSize=<N>进行设置。

 

什么情况下触发垃圾回收

由于对象进行了分代处理，因此垃圾回收区域、时间也不一样。GC有两种类型：Scavenge GC和Full GC。

Scavenge GC

一般情况下，当新对象生成，并且在Eden申请空间失败时，就会触发Scavenge GC，对Eden区域进行GC，清除非存活对象，并且把尚且存活的对象移动到Survivor区。然后整理Survivor的两个区。这种方式的GC是对年轻代的Eden区进行，不会影响到年老代。因为大部分对象都是从Eden区开始的，同时Eden区不会分配的很大，所以Eden区的GC会频繁进行。因而，一般在这里需要使用速度快、效率高的算法，使Eden去能尽快空闲出来。

对整个堆进行整理，包括Young、Tenured和Perm。Full GC因为需要对整个块进行回收，所以比Scavenge GC要慢，因此应该尽可能减少Full GC的次数。在对JVM调优的过程中，很大一部分工作就是对于FullGC的调节。有如下原因可能导致Full GC：

 

· 年老代（Tenured）被写满

· 持久代（Perm）被写满

· System.gc()被显示调用

·上一次GC之后Heap的各域分配策略动态变化

 

5. 一个简单的例子

---

 

下面这个例子向大家展示了垃圾收集所经历的过程，并对前面的陈述进行了总结。

class Chair {

        static boolean gcrun = false;

        static boolean f = false;

        static int created = 0;

        static int finalized = 0;

        int i;

        Chair() {

                 i = ++created;

                 if(created == 47)

                 System.out.println("Created 47");

        }

        protected void finalize() {

                 if(!gcrun) {

                           gcrun = true;

                           System.out.println("Beginning to finalize after " + created + " Chairs have been created");

                 }

                 if(i == 47) {

                           System.out.println("Finalizing Chair #47， " +"Setting flag to stop Chair creation");

                           f = true;

                 }

                 finalized++;

                 if(finalized >= created)

                 System.out.println("All " + finalized + " finalized");

        }

}

public class Garbage {

        public static void main(String[] args) {

                 if(args.length == 0) {

                 System.err.println("Usage: \n" + "java Garbage before\n or:\n" + "java Garbage after");

                 return;

        }

                 while(!Chair.f) {

                           new Chair();

                           new String("To take up space");

                 }

                 System.out.println("After all Chairs have been created:\n" + "total created = " + Chair.created +

                 "， total finalized = " + Chair.finalized);

                 if(args[0].equals("before")) {

                           System.out.println("gc():");

                           System.gc();

                           System.out.println("runFinalization():");

                           System.runFinalization();

                 }

                 System.out.println("bye!");

                 if(args[0].equals("after"))

                 System.runFinalizersOnExit(true);

        }

}

上面这个程序创建了许多Chair对象，而且在垃圾收集器开始运行后的某些时候，程序会停止创建Chair。由于垃圾收集器可能在任何时间运行，所以我们不能准确知道它在何时启动。因此，程序用一个名为gcrun的标记来指出垃圾收集器是否已经开始运行。利用第二个标记f，Chair可告诉main()它应停止对象的生成。这两个标记都是在finalize()内部设置的，它调用于垃圾收集期间。另两个static变量--created以及finalized--分别用于跟踪已创建的对象数量以及垃圾收集器已进行完收尾工作的对象数量。最后，每个Chair都有它自己的（非static）int i，所以能跟踪了解它具体的编号是多少。编号为47的Chair进行完收尾工作后，标记会设为true，最终结束Chair对象的创建过程。