Java的内存回收机制

在Java中，它的内存管理包括两方面：内存分配（建立Java对象的时候）和内存回收，这两方面工做都是由JVM自动完成的，下降了Java程序员的学习难度，避免了像C/C++直接操做内存的危险。可是，也正由于内存管理彻底由JVM负责，因此也使Java不少程序员再也不关心内存分配，致使不少程序低效，耗内存。所以就有了Java程序员到最后应该去了解JVM，才能写出更高效，充分利用有限的内存的程序。

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"));,内存很是紧张的时候会被回收，其余时候不会被回收，因此在使用以前要判断是否为null从而判断他是否已经被回收了。

3）弱引用 ：经过WeakReference类实现，eg : WeakReference<Person> p = new WeakReference<Person>(new Person("Rain"));无论内存是否足够，系统垃圾回收时一定会回收。

4）虚引用 ：不能单独使用，主要是用于追踪对象被垃圾回收的状态。经过PhantomReference类和引用队列ReferenceQueue类联合使用实现，eg ：

package test;


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);
    }
}

运行结果：

3.Java垃圾回收机制

其实Java垃圾回收主要作的是两件事：1）内存回收 2）碎片整理

3.1垃圾回收算法

1）串行回收（只用一个CPU）和并行回收（多个CPU才有用）：串行回收是无论系统有多少个CPU，始终只用一个CPU来执行垃圾回收操做，而并行回收就是把整个回收工做拆分红多个部分，每一个部分由一个CPU负责，从而让多个CPU并行回收。并行回收的执行效率很高，但复杂度增长，另外也有一些反作用，如内存碎片增长。

2）并发执行和应用程序中止 ：应用程序中止（Stop-the-world）顾名思义，其垃圾回收方式在执行垃圾回收的同时会致使应用程序的暂停。并发执行的垃圾回收虽然不会致使应用程序的暂停，但因为并发执行垃圾须要解决和应用程序的执行冲突（应用程序可能在垃圾回收的过程修改对象），所以并发执行垃圾回收的系统开销比Stop-the-world高，并且执行时须要更多的堆内存。

3）压缩和不压缩和复制 ：

①支持压缩的垃圾回收器（标记-压缩 = 标记清除+压缩）会把全部的可达对象搬迁到一端，而后直接清理掉端边界之外的内存，减小了内存碎片。

②不压缩的垃圾回收器（标记-清除）要遍历两次，第一次先从跟开始访问全部可达对象，并将他们标记为可达状态，第二次便利整个内存区域，对未标记可达状态的对象进行回收处理。这种回收方式不压缩，不须要额外内存，但要两次遍历，会产生碎片

③复制式的垃圾回收器：将堆内存分红两个相同空间，从根（相似于前面的有向图起始顶点）开始访问每个关联的可达对象，将空间A的所有可达对象复制到空间B，而后一次性回收空间A。对于该算法而言，由于只需访问全部的可达对象，将全部的可达对象复制走以后就直接回收整个空间，彻底不用理会不可达对象，因此遍历空间的成本较小，但须要巨大的复制成本和较多的内存。

          

3.2堆内存的分代回收

1）分代回收的依据：

①对象生存时间的长短：大部分对象在Young期间就被回收

②不一样代采起不一样的垃圾回收策略：新（生存时间短）老（生存时间长）对象之间不多存在引用

2) 堆内存的分代：

①Young代 ：

Ⅰ回收机制 ：由于对象数量少，因此采用复制回收。

Ⅱ组成区域 ：由1个Eden区和2个Survivor区构成，同一时间的两个Survivor区，一个用来保存对象，另外一个是空的；每次进行Young代垃圾回收的时候，就把Eden，From中的可达对象复制到To区域中，一些生存时间长的就复制到了老年代，接着清除Eden，From空间，最后原来的To空间变为From空间，原来的From空间变为To空间。

Ⅲ对象来源 ：绝大多数对象先分配到Eden区，一些大的对象会直接被分配到Old代中。

Ⅳ回收频率 ：由于Young代对象大部分很快进入不可达状态，所以回收频率高且回收速度快

          

②Old代 ：

Ⅰ回收机制 ：采用标记压缩算法回收。

Ⅱ对象来源 ：1.对象大直接进入老年代。

　　　　　　 2.Young代中生存时间长的可达对象

Ⅲ回收频率 ：由于不多对象会死掉，因此执行频率不高，并且须要较长时间来完成。

③Permanent代 ：

Ⅰ用      途 ：用来装载Class，方法等信息，默认为64M，不会被回收

Ⅱ对象来源 ：eg：对于像Hibernate，Spring这类喜欢AOP动态生成类的框架，每每会生成大量的动态代理类，所以须要更多的Permanent代内存。因此咱们常常在调试Hibernate，Spring的时候常常遇到java.lang.OutOfMemoryError:PermGen space的错误，这就是Permanent代内存耗尽所致使的错误。

Ⅲ回收频率 ：不会被回收

 

3.3常见的垃圾回收器

在此以前，咱们先讲一下下面将会涉及到的并发和并行两个词的解释：

1）并行：指多条垃圾收集线程并行工做，但此时用户线程仍然处于等待状态；

2）并发：指用户线程与 垃圾收集线程同时执行（但不必定是并行的，可能会交替执行），用户程序继续执行，而垃圾收集程序运行于另外一个CPU上。

好啦，继续讲垃圾回收器：

1）串行回收器（只使用一个CPU）：Young代采用串行复制算法；Old代使用串行标记压缩算法（三个阶段：标记mark—清除sweep—压缩compact），回收期间程序会产生暂停，

2）并行回收器：对Young代采用的算法和串行回收器同样，只是增长了多CPU并行处理； 对Old代的处理和串行回收器彻底同样，依旧是单线程。

3）并行压缩回收器：对Young代处理采用与并行回收器彻底同样的算法；只是对Old代采用了不一样的算法，其实就是划分不一样的区域，而后进行标记压缩算法：

① 将Old代划分红几个固定区域；

② mark阶段（多线程并行），标记可达对象；

③ summary阶段（串行执行），从最左边开始检验知道找到某个达到数值（可达对象密度小）的区域时，此区域及其右边区域进行压缩回收，其左端为密集区域

④ compact阶段（多线程并行），识别出须要装填的区域，多线程并行的把数据复制到这些区域中。经此过程后，Old代一端密集存在大量活动对象，另外一端则存在大块空间。

4）并发标识—清理回收（CMS）：对Young代处理采用与并行回收器彻底同样的算法；只是对Old代采用了不一样的算法，但归根待地仍是标记清理算法：

① 初始标识（程序暂停）：标记被直接引用的对象(一级对象)；

② 并发标识（程序运行）：经过一级对象寻找其余可达对象；

③ 再标记（程序暂停）：多线程并行的从新标记以前可能由于并发而漏掉的对象（简单的说就是防遗漏）

④ 并发清理（程序运行）

4.内存管理小技巧

1）尽可能使用直接量，eg：String javaStr = "小学徒的成长历程";

2）使用StringBuilder和StringBuffer进行字符串链接等操做;

3）尽早释放无用对象;

4）尽可能少使用静态变量;

5）缓存经常使用的对象:可使用开源的开源缓存实现，eg：OSCache，Ehcache;

6）尽可能不使用finalize()方法;

7）在必要的时候能够考虑使用软引用SoftReference。