引用类型

简介

从JDK1.2版本开始，加入了对象的几种引用级别，从而使程序能够更好的控制对象的生命周期，帮助开发者能够更好的缓解和处理内存泄露的问题。

引用级别由高到低分别为：强引用、软引用、弱引用和虚引用。

强引用（StrongReference）

Java 的默认引用实现,Object object=new Object();那object就是一个强引用了,垃圾回收器绝不会回收具有对象引用的强引用。当内存空间不足,Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题;没有任何对象指向它时gc执行后将会被回收。

软引用（SoftReference）

如果一个对象只具有软引用，当内存足够时不会回收这种引用类型的对象，只有当内存不够用时才会回收，这种特点很适合用来实现内存敏感的高速缓存，比如Android中图片的缓存。只要垃圾回收器没有回收它，该对象就可以被程序使用。
软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

弱引用（WeakReference）

弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。
弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

虚引用（PhantomReference）

虚引用不会决定对象的生命周期。如果一个对象只具有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。 虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列 （ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。
ReferenceQueue queue = new ReferenceQueue ();
PhantomReference pr = new PhantomReference (object, queue);
程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队 列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

好处：

1.它可以让我们准确地知道对象何时被从内存中删除， 这个特性可以被用于一些特殊的需求中(例如 Distributed GC， XWork 和 google-guice 中也使用 PhantomReference 做了一些清理性工作).
2.它可以避免 finalization 带来的一些根本性问题, PhantomReference 的唯一作用就是跟踪 referent 何时被 enqueue 到 ReferenceQueue 中, 但是 WeakReference 也有对应的功能, 两者的区别到底在哪呢?
这就要说到 Object 的 finalize 方法, 此方法将在 gc 执行前被调用, 如果某个对象重载了 finalize 方法并故意在方法内创建本身的强引用, 这将导致这一轮的 GC 无法回收这个对象并有可能
引起任意次 GC， 最后的结果就是明明 JVM 内有很多 Garbage 却 OutOfMemory， 使用 PhantomReference 就可以避免这个问题， 因为 PhantomReference 是在 finalize 方法执行后回收的，也就意味着此时已经不可能拿到原来的引用, 也就不会出现上述问题, 当然这是一个很极端的例子, 一般不会出现.

引用对列(ReferenceQueue)

可以监控被回收的Reference对象，具体的就是当一个引用对象他所引用的值被回收了，那么系统就会把这个引用添加到这个对列里面

在java.lang.ref包中提供了三个类：SoftReference类、WeakReference类和PhantomReference类，它们分别代表软引用、弱引用和虚引用。ReferenceQueue类表示引用队列，它可以和这三种引用类联合使用，以便跟踪Java虚拟机回收所引用的对象的活动。

简例:

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

public class Main {
    public static void main(String[] args) {
        System.out.println("强引用------------------------------------------------");
        User user1 = new User("liang");
        System.out.println(user1);
        user1=null;
        System.gc();
        System.gc();
        System.out.println(user1);

        System.out.println("软引用------------------------------------------------");
        User user2 = new User("liang");
        SoftReference<User> ref2 = new SoftReference<User>(user2);
        System.out.println(ref2.get());
        user2 = null;
        System.gc();
        System.gc();
        System.out.println(ref2.get());

        System.out.println("弱引用------------------------------------------------");
        User user3 = new User("liang");
        WeakReference<User> ref3 = new WeakReference<User>(user3);
        System.out.println(ref3.get());
        user3 = null;
        System.gc();
        System.gc();
        System.out.println(ref3.get());

        System.out.println("虚引用------------------------------------------------");
        User user4 = new User("liang");
        ReferenceQueue rq = new ReferenceQueue();
        PhantomReference<User> ref4 = new PhantomReference<User>(user4, rq);
        System.out.println(ref4.get());
    }
}

结果

强引用------------------------------------------------
liang
null
软引用------------------------------------------------
liang
liang
弱引用------------------------------------------------
liang
null
虚引用------------------------------------------------
null

 简例

import java.lang.ref.*;
import java.util.HashSet;
import java.util.Set;

class Grocery {
    private static final int SIZE = 10000;
    // 属性d使得每个Grocery对象占用较多内存，有80K左右
    private double[] d = new double[SIZE];
    private String id;

    public Grocery(String id) {
        this.id = id;
    }

    public String toString() {
        return id;
    }

    public void finalize() {
        System.out.println("Finalizing " + id);
    }
}

public class Main {
    private static ReferenceQueue<Grocery> rq = new ReferenceQueue<Grocery>();

    public static void checkQueue() {
        Reference<? extends Grocery> inq = rq.poll(); // 从队列中取出一个引用
        if (inq != null)
            System.out.println("In queue: " + inq + " : " + inq.get());
    }

    public static void main(String[] args) {
        final int size = 10;
        System.out.println("软引用--------------------------------------------");
        // 创建10个Grocery对象以及10个软引用
        Set<SoftReference<Grocery>> sa = new HashSet<SoftReference<Grocery>>();
        for (int i = 0; i < size; i++) {
            SoftReference<Grocery> ref = new SoftReference<Grocery>(
                    new Grocery("Soft " + i), rq);
            System.out.println("created: " + ref.get());
            sa.add(ref);
        }
        System.gc();
        checkQueue();
        System.out.println("弱引用--------------------------------------------");
        // 创建10个Grocery对象以及10个弱引用
        Set<WeakReference<Grocery>> wa = new HashSet<WeakReference<Grocery>>();
        for (int i = 0; i < size; i++) {
            WeakReference<Grocery> ref = new WeakReference<Grocery>(
                    new Grocery("Weak " + i), rq);
            System.out.println("created: " + ref.get());
            wa.add(ref);
        }
        System.gc();
        checkQueue();
        System.out.println("虚引用--------------------------------------------");
        // 创建10个Grocery对象以及10个虚引用
        Set<PhantomReference<Grocery>> pa = new HashSet<PhantomReference<Grocery>>();
        for (int i = 0; i < size; i++) {
            PhantomReference<Grocery> ref = new PhantomReference<Grocery>(
                    new Grocery("Phantom " + i), rq);
            System.out.println("created: " + ref.get());
            pa.add(ref);
        }
        System.gc();
        checkQueue();
    }
}

结果

软引用--------------------------------------------
created: Soft 0
created: Soft 1
created: Soft 2
created: Soft 3
created: Soft 4
created: Soft 5
created: Soft 6
created: Soft 7
created: Soft 8
created: Soft 9
弱引用--------------------------------------------
created: Weak 0
created: Weak 1
created: Weak 2
created: Weak 3
created: Weak 4
created: Weak 5
created: Weak 6
created: Weak 7
created: Weak 8
created: Weak 9
Finalizing Weak 7
Finalizing Weak 2
Finalizing Weak 1
Finalizing Weak 0
Finalizing Weak 9
Finalizing Weak 8
Finalizing Weak 5
Finalizing Weak 4
Finalizing Weak 3
Finalizing Weak 6
In queue: java.lang.ref.WeakReference@29453f44 : null
虚引用--------------------------------------------
created: null
created: null
created: null
created: null
created: null
created: null
created: null
created: null
created: null
created: null
Finalizing Phantom 5
Finalizing Phantom 3
Finalizing Phantom 2
Finalizing Phantom 1
Finalizing Phantom 6
Finalizing Phantom 4
Finalizing Phantom 0
Finalizing Phantom 9
Finalizing Phantom 8
Finalizing Phantom 7
In queue: java.lang.ref.WeakReference@61bbe9ba : null