02-Reference & GC

一、引用
    Java中引用的定义很传统:如果reference类型的数据中存储的数值代表的是另外一块内存的起始地址,就称这块内存代表着一个引用。这个定义很纯粹,但是太过狭隘,一个对象在这种定义下只有被引用或者没有被引用两种状态,对于如何描述一些“食之无味弃之可惜”的对象就显得无能为力。我们希望能描述这样一类对象:当内存空间还足够时,则能保存在内存中;如果内存在进行垃圾收集后还是非常紧张,则可以抛弃这些对象。很多系统的缓存功能都符合这样的应用场景。
    在JDK1.2之后,Java对引用的概念进行了扩充,将引用分为:
        以下四种引用强度依次逐渐减弱
        1.强引用(Strong Reference)
            强引用就是指在程序代码中普遍存在的,类似“Object obj = new Object()”这类的引用,只要强引用还存在,垃圾收集器永远不会回收掉被引用的对象。
        2.软引用(Soft Reference)
            软引用用来描述一些还有用,但并非必须的对象。对于软引用关联着的对象,在系统将要发生内存溢出异常之前,会把这些对象列进回收范围之中并进行第二次回收。如果这次回收还是没有足够的内存,才会抛出内存溢出异常。在JDK1.2之后,提供了SoftReference类来实现软引用。
        3.弱引用(Weak Reference)
            弱引用也是用来描述非必须对象的,但是它的强度比弱引用更弱一些,被弱引用关联的对象只能生存到下一次垃圾收集器发生之前。当垃圾收集器工作时,无论当前的内存是否足够,都会回收掉只被弱引用关联的对象。在JDK1.2之后,提供了WeakReference类来实现弱引用。
        4.虚引用(Phantom Reference)
            虚引用也称为幽灵引用或者幻影引用,它是最弱的一种引用关系。一个对象是否有虚引用的存在,完全不会对其生存时间构成影响,也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一目的就是希望能在这个对象被收集器回收时收到一个系统通知。在JDK1.2之后,提供了PhantomReference来实现虚引用。
二、判断对象已死算法
    1.引用计数算法(Reference Counting)
        定义:给对象中添加一个引用计数器,每当有个地方引用它时,计算器值就加一;当引用失效时,计数器值就减1;任何时候计算器都为0的对象就是不可能再被使用的。
        客观地说,引用计数算法的实现简单,判定效率也很高,在大部分情况下它都是一个不错的算法,但是Java中没有选用它来管理内存,其中最主要的原因是它很难解决对象之间的相互循环引用的问题
    2.根搜索算法(GC Roots Tracing)
        基本思路:通过一系列名为”GC Roots”的对象作为起始点,从这些节点开始往下搜索,搜索走过的路径称为引用链(Reference Chain),当一个对象到GC Roots没有任何引用链相连(用图论的话来说就是从GC Roots到这个对象不可达)时,则证明此对象是不可用的。
        在Java语言里,可作为GC Roots的对象包括以下几种:
        1.虚拟机栈(栈帧中的本地变量表)中引用的对象。
        2.方法区中的类静态属性引用的对象。
        3.方法区中的常量引用的对象。
        4.本地方法栈JNI(即一般说的Native方法)的引用的对象。
三、对象死亡的两次标记过程
    在根搜索算法中不可达的对象,也并非是“非死不可”的,这时候它们暂时处于“缓刑”阶段,要真正宣告一个对象死亡,至少要经过两次标记过程:如果对象在进行根搜索后发现没有与GC Roots相连接的引用链,那它会被第一次标记并且进行一次筛选,筛选的条件是此对象是否有必要执行finalize()方法。当对象没有覆盖finalize方法或者finalize已经被虚拟机调用过,虚拟机将这两种情况都视为“没有必要执行”。
    经过上面的判定如果有必要执行finalize方法,那么这个对象将会被放置在一个名为F-Queue的队列之中,并在稍后由一条虚拟机自动建立的、低优先级的Finalizer线程去执行。这里所谓的“执行”是指虚拟机会触发这个方法,但并不承诺会等待它运行结束。这样做的原因是,如果一个对象在finalize方法中执行缓慢,或者发生了死循环(更极端的情况),将很可能会导致F-Queue队列中的其他对象永久处于等待状态,甚至导致整个内存回收系统崩溃。finalize方法是对象逃脱死亡命运的最后一次机会,稍后GC将对F-Queue中的对象进行第二次小规模的标记,如果对象要在finalize中拯救自己–只要重新与引用链上的任何一个对象建立关联即可,譬如把自己(this关键字)赋值给某个类的变量或对象的成员变量,那在第二次标记时它将被移除出“即将回收”的集合;如果对象这时候还没有逃脱,那它就真的离死不远了。
代码测试如下:
package com.billstudy.jvm;
/**
 * Created by Bill on 2015-07-16 16:11
 * 测试GC自救,finalize只会被调用一次
 * Email: LuckyBigBill@gmail.com
 */
public class FinalizeEscapeGC {
    public static FinalizeEscapeGC SAVE_HOOK = null;
    public void isAlive(){
        System.out.println("yes, i am still alive :)");
    }
    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("finalize method executed!");
        SAVE_HOOK = this;
    }
    public static void main(String[] args) throws Exception{
        SAVE_HOOK = new FinalizeEscapeGC();
        // 对象第一次拯救自己
        SAVE_HOOK = null;
        System.gc();
        // Finalizer方法优先级低,暂停等会儿它
        Thread.sleep(500);
        if (SAVE_HOOK != null){
            SAVE_HOOK.isAlive();
        }else{
            System.out.println("no, i am dead :(");
        }
        // 和上面代码相同,这次自救失败了
        SAVE_HOOK = null;
        System.gc();
        Thread.sleep(500);
        if (SAVE_HOOK != null){
            SAVE_HOOK.isAlive();
        }else{
            System.out.println("no, i am dead :(");
        }
    }
}
// 输出结果
finalize method executed!
yes, i am still alive : )
no, i am dead : (

四、垃圾回收算法
    1.标记-清除算法
        该算法分为”标记”和“清除”两个阶段:首先标记出所有需要回收的对象,在标记完成后统一回收掉所有被标记的对象.
         主要缺点:
                1.效率问题,标记和清除过程的效率都不高
                2.空间问题,标记清除之后会产生大量不连续的内存碎片,空间碎片太多可能会导致,当程序在以后的运行过程中需要分配较大对象时无法找到足够的连续内存而不得不提前触发另一次垃圾收集动作。
         回收示意图:
          2882931d-b8f4-48f7-a62a-9c6c8510ece4
    2.复制算法
        为了解决效率问题,一种称为“复制”(Copying)的收集算法出现了,它将可用内存按容量划分为大小相等的两快,每次只使用其中的一块。当这一块的内存用完了,就将还存活着的对象复制到另外一块上,然后再把已使用过的内存空间一次清理掉。这样使得每次都是要对其中的一块进行内存回收,内存分配时也就不用考虑内存碎片等复杂情况,只要移动堆顶指针,按顺序分配内存即可。实现简单,运行高效。只是这种算法的代价是将内存缩小为原来的一半,未免太高了一点
655d7bc7-8042-4851-bde0-6456ec4734e3
    3.标记-整理算法
        复制收集算法在对象存活率较高时就要执行较多的复制操作,效率将会变低。更关键的是,如果不想浪费50%的空间,就需要有额外的空间进行分配担保,以应对被使用的内存中所有对象都100%存活极端情况,所以老年代一般不能直接选用这种算法。
        根据老年代的特点,有人提出了另外一种”标记-整理”(Mark-Compact)算法,标记过程仍然与“标记-清除一样”,但后续步骤不是直接对可回收对象进行清理,而是让所有存活的对象都想一端移动,然后直接清理掉端边界以外的内存,示意图如下:
02f7255a-899e-47b2-91a3-e19b000b4095
    4.分代收集算法
        当前商业虚拟机的垃圾收集都采用”分代收集”(Generational Collection)算法,这种算法并没有什么新的思想,只是根据对象的存活周期的不同将内存划分为几块。一般是把Java堆分为新生代和老年代,这样就可以根据各个年代的特点采用最适当的收集算法。在新生代中,每次垃圾收集时都发现有大批对象死去,只有少量存活。那就选用复制算法,只需要付出少量存活对象的复制成本就可以完成收集。而老年代中因为对象存活率高、没有额外空间对它进行分配担保,就必须使用”标记-清理”或“标记-整理”算法来进行回收
        
新生代GC(Minor GC):
    指发生在新生代的垃圾收集动作,因为Java对象大多都具备朝生暮死的特性,所以Minor GC非常频繁,一般回收速度也比较快。
 
老年代GC(Major GC / Full GC):
    指发生在老年代的GC,出现了Major GC,经常会伴随至少一次的Minor GC(但非绝对的,在ParallelScavenge的收集器的收集策略里就有直接进行Major GC的策略选择过程)。MajorGC的速度一般会比Minor GC慢10倍以上。
 
 
当一个对象超过15岁(默认)之后,就进入老年代。可以通过-XX:MaxTenuringThreshold设置

Bill

赶紧打开电脑 写两行代码压压惊 ~

发表评论

电子邮件地址不会被公开。 必填项已用*标注