java垃圾处理

Java垃圾回收机制

1. 垃圾回收的意义
　　在C++中，对象所占的内存在程序结束运行之前一直被占用，在明确释放之前不能分配给其它对象；而在Java中，当没有对象引用指向原先分配给某个对象的内存时，该内存便成为垃圾。JVM的一个系统级线程会自动释放该内存块。垃圾回收意味着程序不再需要的对象是"无用信息"，这些信息将被丢弃。当一个对象不再被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用。事实上，除了 释放没用的对象，垃圾回收也可以 清除内存记录碎片。由于创建对象和垃圾回收器释放丢弃对象所占的内存空间，内存会出现碎片。碎片是分配给对象的内存块之间的空闲内存洞。碎片整理将所占用的堆内存移到堆的一端，JVM将整理出的内存分配给新的对象。
　　垃圾回收能自动释放内存空间，减轻编程的负担。这使Java 虚拟机具有一些优点。首先，它能使编程效率提高。在没有垃圾回收机制的时候，可能要花许多时间来解决一个难懂的存储器问题。在用Java语言编程的时候，靠垃圾回收机制可大大缩短时间。其次是它保护程序的完整性， 垃圾回收是Java语言安全性策略的一个重要部份。

　　垃圾回收的一个潜在的缺点是它的开销影响程序性能。Java虚拟机必须追踪运行程序中有用的对象，而且最终释放没用的对象。这一个过程需要花费处理器的时间。其次垃圾回收算法的不完备性，早先采用的某些垃圾回收算法就不能保证100%收集到所有的废弃内存。当然随着垃圾回收算法的不断改进以及软硬件运行效率的不断提升，这些问题都可以迎刃而解。

2. 四个引用 ——强 软 弱 虚

           强引用：new关键字创建的。只要强引用还存在，垃圾收集器永远不会回收掉。

           软引用：用来描述还有用但不是必须的对象。（例如：缓存的数据）在系统将要发生内存溢出时，会把这些对象列入回收范围，第二次回收。

           弱引用：也用来描述非必需对象，被弱引用关联的对象只能存活到下一次垃圾回收之前。无论内存是否足够，都会回收掉。

           虚引用：一个对象是否有虚引用不会对它的生存时间产生任何影响，无法从虚引用获得一个对象实例。虚引用存在的目的就是对象被回收时得到系统的通知。

3. 垃圾收集的算法分析

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

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

　　 3 .1. 引用计数法(Reference Counting Collector)

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

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

　　 3 .2. 可达性分析算法

           使用GCRoots作为起点，从这些节点开始向下搜索，搜索走过的路径叫做引用链，当一个对象到GCRoots没有任何引用，就证明此对象是不可用的。

            可作为GCRoots的对象有：（1）虚拟机栈引用的对象     （2）方法区静态变量引用的对象     （3）方法区常量引用的对象     （4）本地方法栈中引用的对象

        3.3 标记——清除 算法

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

             （1）首先标记出所有需要回收的对象。（2）标记完成后统一回收

             缺点：效率不高，且产生内存碎片。

　　 3 .4 复制算法(Coping Collector)

          把内存分为大小相等的两块，每次使用其中一块。当这一块内存用完了，将存活的对象存入另外一块中。这种方法只要移动堆顶的指针即可。

         优点：（1）实现简单（2）运行高效        缺点：浪费了50%的内存。

          现在商业虚拟机都采用这种方法回收新生代。内存分为一块较大的Eden空间和两块较小的Survivor空间。大小比是8:1。

          每次使用Eden和一块Survivor，这两块内存满后，回收对象，将仍然存活的对象copy进入另一块Survivor中。当存活的对象大于这块内存时，就需要依赖其他内存（老年代）进行分配担保。

　　 3 .5. 标记——整理算法

           coping算法在对象存活较多时效率较低，且需要额外内存应对大量对象存活的情况。所以不适用于老年代。

         根据老年代的特点： （1）标记出需要回收的对象        （2）将存活的对象向一端移动        （3）清理边界以外的内存

　　 3 .6. 分代收集算法

           根据对象存在时间不同，把堆分为新生代和老生代。并采用不同的算法进行垃圾收集。

4. System.gc()方法

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

5. finalize()方法

      在JVM垃圾回收器收集一个对象之前，一般要求程序调用适当的方法释放资源，但在没有明确释放资源的情况下，Java提供了缺省机制来终止该对象心释放资源，这个方法就是finalize（）。它的原型为：
　　protected void finalize() throws Throwable
　　在finalize()方法返回之后，对象消失，垃圾收集开始执行。原型中的throws Throwable表示它可以抛出任何类型的异常。
　　之所以要使用finalize()，是存在着垃圾回收器不能处理的特殊情况。假定你的对象（并非使用new方法）获得了一块“特殊”的内存区域，由于垃圾回收器只知道那些显示地经由new分配的内存空间，所以它不知道该如何释放这块“特殊”的内存区域，那么这个时候java允许在类中定义一个由finalize()方法。

      特殊的区域例如：1）由于在分配内存的时候可能采用了类似 C语言的做法，而非JAVA的通常new做法。这种情况主要发生在native method中，比如native method调用了C/C++方法malloc()函数系列来分配存储空间，但是除非调用free()函数，否则这些内存空间将不会得到释放，那么这个时候就可能造成内存泄漏。但是由于free()方法是在C/C++中的函数，所以finalize()中可以用本地方法来调用它。以释放这些“特殊”的内存空间。2）又或者打开的文件资源，这些资源不属于垃圾回收器的回收范围。
      换言之，finalize()的主要用途是释放一些其他做法开辟的内存空间，以及做一些清理工作。因为在JAVA中并没有提够像“析构”函数或者类似概念的函数，要做一些类似清理工作的时候，必须自己动手创建一个执行清理工作的普通方法，也就是override Object这个类中的finalize()方法。例如，假设某一个对象在创建过程中会将自己绘制到屏幕上，如果不是明确地从屏幕上将其擦出，它可能永远都不会被清理。如果在finalize()加入某一种擦除功能，当GC工作时，finalize()得到了调用，图像就会被擦除。要是GC没有发生，那么这个图像就会

被一直保存下来。

           一旦垃圾回收器准备好释放对象占用的存储空间，首先会去调用finalize()方法进行一些必要的清理工作。 只有到下一次再进行垃圾回收动作的时候，才会真正释放这个对象所占用的内存空间。
　　在普通的清除工作中，为清除一个对象，那个对象的用户必须在希望进行清除的地点调用一个清除方法。这与C++"析构函数"的概念稍有抵触。在C++中，所有对象都会破坏（清除）。或者换句话说，所有对象都"应该"破坏。若将C++对象创建成一个本地对象，比如在堆栈中创建（在Java中是不可能的，Java都在堆中），那么清除或破坏工作就会在"结束花括号"所代表的、创建这个对象的作用域的末尾进行。若对象是用new创建的（类似于Java），那么当程序员调用C++的 delete命令时（Java没有这个命令），就会调用相应的析构函数。若程序员忘记了，那么永远不会调用析构函数，我们最终得到的将是一个内存"漏洞"，另外还包括对象的其他部分永远不会得到清除。

　　相反，Java不允许我们创建本地（局部）对象--无论如何都要使用new。但在Java中，没有"delete"命令来释放对象，因为垃圾回收器会帮助我们自动释放存储空间。所以如果站在比较简化的立场，我们可以说正是由于存在垃圾回收机制，所以Java没有析构函数。然而，随着以后学习的深入，就会知道垃圾收集器的存在并不能完全消除对析构函数的需要，或者说不能消除对析构函数代表的那种机制的需要（原因见下一段。另外finalize()函数是在垃圾回收器准备释放对象占用的存储空间的时候被调用的，绝对不能直接调用finalize()，所以应尽量避免用它）。若希望执行除释放存储空间之外的其他某种形式的清除工作，仍然必须调用Java中的一个方法。它等价于C++的析构函数，只是没后者方便。

           在C++中所有的对象运用delete()一定会被销毁，而JAVA里的对象并非总会被垃圾回收器回收。In another word, 1 对象可能不被垃圾回收，2 垃圾回收并不等于“析构”，3 垃圾回收只与内存有关。也就是说，并不是如果一个对象不再被使用，是不是要在finalize()中释放这个对象中含有的其它对象呢？不是的。因为无论对象是如何创建的，垃圾回收器都会负责释放那些对象占有的内存。

7 枚举根节点 、安全点、安全区域

枚举根节点：在可达性分析中，从GCRoots找引用链，如果逐个去找，耗时较多。利用OopMap这个数据结构，在类加载时候记录引用的位置。

安全点：引用变化时，如果对应每条指令都生成oopMap，需要大量的额外空间。只有在特定位置记录这些信息，这些位置称为“安全点”。只有在safe－point程序才能停下来进行gc。

                        要考虑的问题：如何在GC发生时让所有线程都跑到安全点再停顿下来：、

                               （1）抢先式中断：不需要线程配合，先强制停止线程，如果没达到安全点再恢复线程，跑到安全点停下

                              （2）主动式中断：GC需要中断的时候设置一个标志。各个线程轮询这个标志，自动挂起。轮询点和安全点重合即可。

安全区域：

                         某段程序不执行的时候，无法进入safe－point。如线程sleep时，这时需要定义一段安全区域。指在这段代码当中对象引用关系不会改变，在这段代码任意一段开始GC都是安全的。 

8. 垃圾收集器

8.1 serial收集器

单线程收集器，采用复制算法。“单线程”的意义不止说明它采用一个cpu工作，而是在说jvm进行垃圾收集时所有用户正常工作的进程都必须停下来（Stop－the－world）。

简单高效

是虚拟机在client模式下默认的新生代垃圾收集器。

8.2 ParNew收集器

是Serial收集器的多线程版本。

收集器的所有控制参数、收集算法、stw、对象分配规则回收策略与Serial完全一致。

8.3 Parallel Scavenge（并行收集）收集器

也是一个新生代收集器，也采用复制算法。不过ParNew关注的是尽可能缩短GC时用户线程的停顿时间。

而 Parallel Scavenge收集器的目的是达到一个可控制的吞吐量。吞吐量 ＝ 运行用户代码时间／（运行用户代码时间＋垃圾收集时间）

如果读者对于收集器不够了解，手工调优困难的时候，使用 Parallel Scavenge配合自适应调节策略，把内存管理调优的事情交给虚拟完成是不错的选择。

8.4 Serial Old收集器

Serial的老年代版本。采用“标记——整理”算法。（复习一下：因为老年代的对象存活率较高，coping算法效率低）

8.5 ParNew Old收集器

“标记——整理”整理算法

8.6 CMS收集器（Concurrent Mark Sweep）

从名字能看出来这是“标记——清除”算法。

步骤：（1）初始标记（2）并发标记（3）重新标记（4）并发清除。

其中（1）（3）仍然需要stop the world。（2）（4）可以和其他进程并发执行。

初始标记只是标记GCRoots所以很快。并发标记就是标记引用链。重新标记则是找到用户进程在并发标记时候变动的对象，这个时间比（1）长些但远小于（2）

8.7 G1收集器

特点：并发与并行 分代收集 空间整合（与CMS的标记清理算法不同，G1从整体来看是标记整理算法，从局部看是复制） 可预测停顿。

G1之所以能建立可预测的停顿时间模型，是因为它可以有计划的避免在整个堆上进行垃圾回收。G1跟踪各个region里面的垃圾堆积的价值大小，在后台维护一个优先列表，每次根据允许手机时间，优先回收价值大的region。这也是Garbage－First名称的由来。

步骤：（1）初始标记（2）并发标记（3）最终标记（4）筛选回收

9. 触发主GC（Garbage Collector）的条件

　　JVM进行次GC的频率很高,但因为这种GC占用时间极短,所以对系统产生的影响不大。更值得关注的是主GC的触发条件,因为它对系统影响很明显。总的来说,有两个条件会触发主GC:

　　1)当应用程序空闲时,即没有应用线程在运行时,GC会被调用。因为GC在优先级最低的线程中进行,所以当应用忙时,GC线程就不会被调用,但以下条件除外。

　　2)Java堆内存不足时,GC会被调用。当应用线程在运行,并在运行过程中创建新对象,若这时内存空间不足,JVM就会强制地调用GC线程,以便回收内存用于新的分配。若GC一次之后仍不能满足内存分配的要求,JVM会再进行两次GC作进一步的尝试,若仍无法满足要求,则 JVM将报“out of memory”的错误,Java应用将停止。

　　由于是否进行主GC由JVM根据系统环境决定,而系统环境在不断的变化当中,所以主GC的运行具有不确定性,无法预计它何时必然出现,但可以确定的是对一个长期运行的应用来说,其主GC是反复进行的。

10 减少GC开销的措施

　　根据上述GC的机制,程序的运行会直接影响系统环境的变化,从而影响GC的触发。若不针对GC的特点进行设计和编码,就会出现内存驻留等一系列负面影响。为了避免这些影响,基本的原则就是尽可能地减少垃圾和减少GC过程中的开销。具体措施包括以下几个方面:

　　(1)不要显式调用System.gc()

　　此函数建议JVM进行主GC,虽然只是建议而非一定,但很多情况下它会触发主GC,从而增加主GC的频率,也即增加了间歇性停顿的次数。

　　(2)尽量减少临时对象的使用

　　临时对象在跳出函数调用后,会成为垃圾,少用临时变量就相当于减少了垃圾的产生,从而延长了出现上述第二个触发条件出现的时间,减少了主GC的机会。

　　(3)对象不用时最好显式置为Null

　　一般而言,为Null的对象都会被作为垃圾处理,所以将不用的对象显式地设为Null,有利于GC收集器判定垃圾,从而提高了GC的效率。

　　(4)尽量使用StringBuffer,而不用String来累加字符串

　　由于String是固定长的字符串对象,累加String对象时,并非在一个String对象中扩增,而是重新创建新的String对象,如Str5=Str1+Str2+Str3+Str4,这条语句执行过程中会产生多个垃圾对象,因为对次作“+”操作时都必须创建新的String对象,但这些过渡对象对系统来说是没有实际意义的,只会增加更多的垃圾。避免这种情况可以改用StringBuffer来累加字符串,因StringBuffer是可变长的,它在原有基础上进行扩增,不会产生中间对象。

　　(5)能用基本类型如Int,Long,就不用Integer,Long对象

　　基本类型变量占用的内存资源比相应对象占用的少得多,如果没有必要,最好使用基本变量。

　　(6)尽量少用静态对象变量

　　静态变量属于全局变量,不会被GC回收,它们会一直占用内存。

　　 (7)分散对象创建或删除的时间

　　集中在短时间内大量创建新对象,特别是大对象,会导致突然需要大量内存,JVM在面临这种情况时,只能进行主GC,以回收内存或整合内存碎片,从而增加主GC的频率。集中删除对象,道理也是一样的。它使得突然出现了大量的垃圾对象,空闲空间必然减少,从而大大增加了下一次创建新对象时强制主GC的机会

11. 关于垃圾回收的几点补充

　　经过上述的说明，可以发现垃圾回收有以下的 几个特点：
　　（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，暗示垃圾收集器来收集该对象，还必须注意该引用的对象是否被监听，如果有，则要去掉监听器，然后再赋空值。

 

参考：

http://blog.sina.com.cn/s/blog_544e54220100dv0q.html

http://java.chinaitlab.com/base/839279_1.html

http://blog.sina.com.cn/s/blog_5ef35aa00100ky9o.html

深入理解java虚拟机