强引用、软引用、弱引用、虚引用、finalize

Java引用介绍

Java从1.2版本开始引入了4种引用，这4种引用的级别由高到低依次为：

强引用 > 软引用 > 弱引用 > 虚引用

⑴强引用（StrongReference）

强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。

⑵软引用（SoftReference）

如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。

软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

⑶弱引用（WeakReference）

弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。

弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

⑷虚引用（PhantomReference）

“虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。

虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列 （ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之 关联的引用队列中。

由于引用和内存回收关系紧密。下面，先通过实例对内存回收有个认识；然后，进一步通过引用实例加深对引用的了解。

import java.util.Date;

public class MyDate extends Date {
    /**
     * Creates a new instance of MyDate
     */
    public MyDate() {
    }

    // 覆盖finalize()方法

    /**
     * 垃圾回收器（garbage collector）决定回收某对象时，就会运行该对象的finalize()方法；
     *
     * 如果一个没有与GCroot 相连接的引用链，那么这个对象就会被第一次标记，判断是否需要执行finalize方法，如果覆盖了finalize则执行覆盖方法，
     * 但是虚拟机并不承诺什么时候调用这个finalize方法，也不保证顺序
     *
     * 没有覆盖finalize则不需要执行finalize方法,finalize方法也是对象最后一次逃脱死亡的机会，可以从新和gc root 建立引用链
     *
     * @throws Throwable
     */
    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("obj [Date: " + this.getTime() + "] is gc");
    }

    @Override
    public String toString() {
        return "Date: " + this.getTime();
    }
}

public class HeapMemeroy {

    // 消耗大量内存
    public static void drainMemory() {


        // 定义50M的数组
        Byte[] b = new Byte[1024 * 1024 * 50 ];
    }
}

Object类（或子类）的finalize()方法在什么情况下被调用

Finalize方法，可以告诉垃圾回收器应该执行的操作
当某个对象被系统收集为无用信息的时候,finalize()将被自动调用,但是jvm不保证finalize()一定被调用,也就是说,finalize()的调用是不确定的…

测试 finalize()

public class Test {

    public static void main(String[] args) throws InterruptedException {
        /**
         * 无任何输出>
         *
         * 结果分析：date虽然设为null，但由于JVM没有执行垃圾回收操作，MyDate的finalize()方法没有被运行。
         */
//        MyDate date = new MyDate();
//        date = null;
//        Thread.sleep(500);


        /**
         *  // 调用了System.gc()，使JVM运行垃圾回收，MyDate的finalize()方法被运行,但是不确保是立即运行，所以要等待500结束。，finalize()方法运行。
         */
//        MyDate date = new MyDate();
//        date = null;
//        System.gc();
//        Thread.sleep(500);


        /**
         * 虽然没有显式调用垃圾回收方法System.gc()，但是由于运行了耗费大量内存的方法，触发JVM进行垃圾回收。
         * JVM的垃圾回收机制，在内存充足的情况下，除非你显式调用System.gc()，否则它不会进行垃圾回收；在内存不足的情况下，垃圾回收将自动运行。 finalize()方法运行。
         */
//        MyDate date = new MyDate();
//        date = null;
//        HeapMemeroy.drainMemory();

    }
}

测试 强引用 软引用 弱引用

import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;

public class RefrenceTest {
    public static void main(String[] args) throws InterruptedException {

        /**
         * myDate是强引用，所以即使显示调用了gc也不会回收。finalize()方法没有被运行。
         */
//        MyDate myDate = new MyDate();
//
//        System.gc();

        /**
         * myDate是强引用，内存不够也不会被回收。 finalize()方法没有被运行。
         */
//        MyDate myDate = new MyDate();
//        HeapMemeroy.drainMemory();


        /**
         * myDate是软引用，内存不够被回收。  finalize()方法运行。
         */
//        SoftReference reference = new SoftReference(new MyDate());;
//        HeapMemeroy.drainMemory();


        /**
         * myDate是软引用，即使显示GC也不会不会回收，除非内存不够。  finalize()方法没有被运行。
         */
//        SoftReference reference = new SoftReference(new MyDate());;
//        System.gc();
//        Thread.sleep(500);


        /**
         * myDate是弱引用，GC时候就会回收。  finalize()方法运行。
         */
//        WeakReference ref = new WeakReference(new MyDate());
//        System.gc();
//        Thread.sleep(500);
        /**
         * myDate是弱引用，内存不够会gcm, GC时候就会回收。 finalize()方法运行。 Thread.sleep(500);是为了等待finalize 运行完毕再结束吗，finalize 并不是在GC的时候立即执行
         */
//        WeakReference ref = new WeakReference(new MyDate());
//        HeapMemeroy.drainMemory();
//        Thread.sleep(500);



    }
}

真正宣告一个对象生存还是死亡？

即使是在可达性分析算法中不可达的对象，也不并非“非死不可”，此时它们暂时处于“缓刑”阶段。

要真正宣告一个对象死亡，至少要经历两次标记过程，如下图所示：

• 注意：
  1、重新与引用链上的任何一个对象建立关联，譬如可以把自己（this关键字）赋值给某个类变量或者对象的成员变量。
  例如：FinalizeEscapeGC.SAVE_HOOK=this；
  2、虚拟机触发finalize()方法的语句：System.gc()；
  Finalize方法：任何一个对象的finalize()方法都只会被系统自动调用一次，如果对象面临下一次回收，它的finalize()方法不会被再次执行，因此，如果再次使用该方法，对象的自救行动是不会成功的了。
  注意：不建议使用这种方法来拯救对象，因为它的运行代价高昂，不确定性大，同时也无法保证各个对象的调用顺序。可以使用try-finally或其他方式来代替，会获得更好的效果。