Java垃圾回收(一) 内存回收简介

内存回收简介

    在Java中，它的内存管理包括两个方面：内存分配和内存回收，这两个方面的工作都是由JVM自动完成的，降低了Java程序员的学习难度，避免了像C/C++直接操作内存的危险。但这也使很多程序员不关心内存分配的问题，导致很多程序低效耗费内存。

    Java语言规范没有明确的说明JVM使用哪种垃圾回收算法。一般常用的算法有下列几种：
    在介绍之前先说明一个概念：根集。大多数垃圾回收算法使用了根集(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算法(Compating Collector)

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

4. Copying算法(Cpoing Collector)

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

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

5. generation算法(Genrational Collector)也就是分代回收

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

6. adaptive算法

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

1.Java在内存中的状态

    开始先看一个例子：

Person.java

package test;import java.io.Serializable;public class Person implements Serializable {static final long serialVersionUID = 1L;String name; // 姓名Person friend;    //朋友public Person() {}public Person(String name) {  super();  this.name = name;}}

Test.java

package test;public class Test{public static void main(String[] args) {  Person p1 = new Person("Kevin");  Person p2 = new Person("Rain");  Person p3 = new Person("Sunny");  p1.friend = p2;  p3 = p2;  p2 = null;}}

    把上面Test.java中main方面里面的对象引用画成一个从main方法开始的对象引用图的话就是这样的（顶点是对象和引用，有向边是引用关系）：

    当程序运行起来之后，把它在内存中的状态看成是有向图之后，可以分为三种：

1. 可达状态：在一个对象创建后，有一个以上的引用变量和它关联，则它处于可达状态。
2. 可恢复状态：如果程序中某个对象不再有引用变量和其相关联，则它将先进入可恢复状态，此时从有向图的起始顶点不能再导航到该对象，在这个状态下，系统的垃圾回收机制准备回收该对象的所占用的内存，在回收之前。系统会调用finalize()方法进行资源清理，如果资源整理后重新让一个以上引用变量和该对象关联，则该对象的状态会再次变为可达状态，否则就会进入不可达状态。
3. 不可达状态：当对象的所有关联都被切断，且系统调用finalize()方法进行资源清理之后依旧没有使该对象变为可达状态，则这个对象将永久性失去引用并且变成不可达状态，系统才会真正的去回收该对象所占用的资源。
   

2. Java对象的4种引用

1. 强引用：创建一个对象并把这个对象直接赋值给一个变量引用，eg:Person person = new Person("sunny");此时不管系统资源有多么紧张都绝对不会被回收。

2. 软引用：通过SoftReference类实现，eg:SoftReference<Person> p = new SoftReference<Person>(new Person（“Rain”))；内存非常紧张的时候会被回收，其他时候不会被回收，因此在使用之前要判断是否已经被回收了。例如：

   class AB {protected void finalize() {    System.out.println("finalize.....");}}public class JavaTest {    public static void main(String[] args) {        for (int i=0 ; i < 10000; i ++) {            new SoftReference<AB> (new AB());        }    }}结果为：finalize.....finalize.....finalize.....结果不一定，看个人电脑了，也可能没有输出，需要创建更多的对象来逼着JVM回收软引用。

3. 弱引用 ：通过WeakReference类实现，eg : WeakReference<Person> p = new WeakReference<Person>(new Person(“Rain”));不管内存是否足够，系统垃圾回收时必定会回收。

   class AB {    protected void finalize() {        System.out.println("finalize.....");    }}public class JavaTest {    public static void main(String[] args) {        WeakReference<AB> wr = new WeakReference<AB> (new AB());        System.gc();    }}输出结果为:finalize.....强制回收垃圾，若引用就会直接被回收

4. 虚引用 ：不能单独使用，主要是用于追踪对象被垃圾回收的状态。通过PhantomReference类和引用队列ReferenceQueue类联合使用实现,例子如下。

import java.lang.ref.PhantomReference;    import java.lang.ref.ReferenceQueue;    public class Test{    public static void main(String[] args) {      //创建一个对象      Person person = new Person("Sunny");        //创建一个引用队列        ReferenceQueue<Person> rq = new ReferenceQueue<Person>();      //创建一个虚引用，让此虚引用引用到person对象      PhantomReference<Person> pr = new PhantomReference<Person>(person, rq);      //切断person引用变量和对象的引用      person = null;      //试图取出虚引用所引用的对象      //发现程序并不能通过虚引用访问被引用对象，所以此处输出为null      System.out.println(pr.get());      //强制垃圾回收      System.gc();      System.runFinalization();      //因为一旦虚引用中的对象被回收后，该虚引用就会进入引用队列中      //所以用队列中最先进入队列中引用与pr进行比较，输出true      System.out.println(rq.poll() == pr);        }    }    输出结果为 ： null true

3. 垃圾回收器分类

1. 串行回收(只用一个cpu)和并行回收(多个cpu才有用):串行回收是不管系统有多少个CPU，始终只用一个CPU来执行垃圾回收操作，而并行回收就是把整个回收工作拆分成对各部分，每个部分由一个CPU负责，从而让多个CPU并行回收。并行回收的执行效率很高，但是复杂度增加，另外也有一些副作用，如内存碎片增加。
2. 并发执行和应用程序停止 ： 应用程序停止(stop-the-world)即在其垃圾回收方式在执行的时候同时会导致应用程序的暂停。并发执行的垃圾回收虽然不会导致应用程序的暂停，由于需要边执行应用程序边垃圾回收(可能在回收的时候修改对象，因此和应用程序的执行存在冲突问题)，并发执行的系统开销比Stop-the-world高，而且需要更多的堆内存。

3. 压缩和不压缩和复制

   • 支持压缩的垃圾回收器(标记-压缩 =标记清楚+压缩)会把所有的可达对象搬迁到一端，然后直接清理掉边界以外的内存，减少了内存碎片。
   • 不支持压缩的垃圾回收器(标记-清除)要遍历两次，第一次先从根开始访问，标记所有可达状态的对象，第二次遍历整个内存区域，对为标记可达状态的对象进行回收处理。这种回收方式不压缩，不需要额外的内存，但需要遍历两次，会产生碎片。
   • 复制式的垃圾回收器：将堆内存分成两个相同的控件，从根开始访问每个可达对象，将A的所有可达对象都复制到B空间，然后一次性回收所有A空间。遍历空间的成本小，不会产生碎片，但需要巨大的复制成本和较多的内存。

4.内存管理技巧

1. 尽量使用直接量。 eg:String s = “hello world”;
2. 使用StringBuilder和StringBuffer进行字符串的连接等操作;
3. 尽早释放无用对象;
4. 少使用静态变量;
5. 缓存常用的对象，可以用开源的开源缓存实现。eg:OSCache,Ehcache;
6. 尽量不使用finalize()方法；
7. 在必要的时候考虑多使用软饮用SoftReference;