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 p = new SoftReference(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 (new AB());
           }
       }
   }
   结果为：finalize.....
   finalize.....
   finalize.....
   结果不一定，看个人电脑了，也可能没有输出，需要创建更多的对象来逼着JVM回收软引用。
   

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

   class AB {
       protected void finalize() {
           System.out.println("finalize.....");
       }
   }
   public class JavaTest {
       public static void main(String[] args) {
           WeakReference wr = new WeakReference (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 rq = new ReferenceQueue();
      //创建一个虚引用，让此虚引用引用到person对象
      PhantomReference pr = new PhantomReference(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;