ference 概念

http://kenwublog.com/arrange-java-reference-concept

Strong Reference, 强引用，即java标准的引用方式，表示GC从 Root Set 开始向下扫描，可以找到对应的 Strong Reference。

Referent，被包装为 Weak, Soft, Phantom Reference的对象引用称之为 referent。后面的内容会多次提到这个名词。

Weak Reference, 弱引用。当一个referent，在运行时没有同时被强，软引用，只被Weak Reference自身引用，且Weak Reference从 Root Set 可达，则该referent会被GC回收。

WR的作用，一般是为referent提供一个被回收的凭据，结合ReferenceQueue可以让程序在第一时间得到referent被回收的事件，从而做一些额外的clean操作。(如果对ReferenceQueue作用和回调感兴趣，可以先看最下面的 ReferenceQueue 简介)


Soft Reference, 软引用。它是除strong外，生命周期最长的一种 Reference，只有当JVM Heap中充满Strong References, Full GC无法为heap腾出更多空间而即将抛出OOM时，SoftReferences会被GC回收。

SR的作用一般是用作不限大小的 cache（无需remove）。
比如将其 Soft Reference 无限地放入 hashmap 中，而不关心hashmap内的对象数量是否会撑爆heap，也不需要手动 remove。
当Heap容量达到OOM触发条件时，VM会自动回收该map里的所有SoftReferences.

Phanton Reference, 是一种特殊的Reference，正如他的名字所表达的，幻影引用，他可以像幻影一样附着在referent上。
当GC在遍历引用关系时，如果发现被phantom reference包装过的referent不存在strong, weak, soft引用时(就是除phantom外没有任何引用，幻影的由来)，GC会将 phantom reference 放入 Reference queue。以便程序在另一边通过queue的remove/poll方法，感知referent被GC回收的事件。(如果对ReferenceQueue作用和回调感兴趣，可以先看最下面 ReferenceQueue 简介)

另外，我们知道，GC在回收对象前会先调用对象自身的finalize()方法，如果它有实现的话，然后再清掉内存。而Phantom Reference的回调(enqueue)是在对象的finalize后，回收前触发。这跟 WeakReference不一样。WR是在回收后才通知的。在这个特殊的阶段可以做一些特殊的clean操作。

为什么 Phantom Reference 的get总是返回null？
因为phantom reference想做到幻影（除自身外，不跟其他任何引用有关联），所以不允许程序能通过自身的get方法得到referent，而破坏幻影的初衷。

实例代码

package com.kenwublog.reference;

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.util.HashMap;

public class PhantomReferenceTest {

public static void main(String[] args) {
ReferenceQueue referenceQueue = new ReferenceQueue();
Object object = new Object() {
public String toString() {
return "Referenced Object";
}
};

Object data = new Object() {
public String toString() {
return "Data";
}
};

HashMap map = new HashMap();
Reference reference = null;
System.out.println("Testing PhantomReference.");
reference = new PhantomReference(object, referenceQueue);

map.put(reference, data);

System.out.println(reference.get()); // null
System.out.println(map.get(reference)); // Data
System.out.println(reference.isEnqueued()); // false

System.gc();
System.out.println(reference.get()); // null
System.out.println(map.get(reference)); // Data
System.out.println(reference.isEnqueued()); // false

object = null;
data = null;

System.gc();
System.out.println(reference.get()); // null
System.out.println(map.get(reference)); // Data
System.out.println(reference.isEnqueued()); // true, because object has been reclaimed.
}

}
ReferenceQueue，一种当 weak, soft, phantom的referent被GC回收后，提供事件回调的接口。需要在实例化三大reference时，通过构造函数传入，phantom reference是强制需要传入的，weak和soft可不传。

回调过程：

GC回收referent后(phantom是在回收前，finalize后)，将reference enqueue到RQ中，程序通过调用RQ的remove方法来感知reference被GC回收的事件。
remove方法是阻塞的，当没有referent被回收时（GC未调用enqueue），remove方法会一直挂起线程，当有referent被回收时，该方法返回 referent对应的reference对象。
同样，RQ也提供了一个非阻塞的方法 poll，但这样就做不到实时回调了。

实例

package com.kenwublog.reference;

import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.HashMap;

public class ReferenceQueueTest {

public static void main(String[] args) {
final ReferenceQueue q = new ReferenceQueue();
String str = new String("AK47");
WeakReference wr = new WeakReference(str, q);

Thread t = new Thread(){
@Override
public void run() {
try {
Reference reference = q.remove();
System.out.println(reference + " event fired.");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
t.setDaemon(true);
t.start();
System.out.println("Reference Queue is listening.");

str = null; // clear strong reference
System.out.println("Ready to gc");
System.gc();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("wr.get: " + wr.get());
}

}


http://blog.csdn.net/imzoer/article/details/8044900
垃圾收集过程中，对象的可触及状态改变的时候，可以把引用对象和引用队列关联起来【这里说的关联，是说垃圾收集器会把要回收的对象添加到引用队列ReferenceQueue】，这样在可触及性发生变化的时候得到“通知”。

当垃圾收集器对加入队列的对象改变可触及性的时候，就可以收到异步通知了。

看下面的代码：

[java] view plaincopyprint?<SPAN style="FONT-FAMILY: Microsoft YaHei; FONT-SIZE: 14px">package static_;

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.reflect.Field;

public class Test {
public static boolean isRun = true;

@SuppressWarnings("static-access")
public static void main(String[] args) throws Exception {
String abc = new String("abc");
System.out.println(abc.getClass() + "@" + abc.hashCode());
final ReferenceQueue<String> referenceQueue = new ReferenceQueue<String>();
new Thread() {
public void run() {
while (isRun) {
Object obj = referenceQueue.poll();
if (obj != null) {
try {
Field rereferent = Reference.class
.getDeclaredField("referent");
rereferent.setAccessible(true);
Object result = rereferent.get(obj);
System.out.println("gc will collect："
+ result.getClass() + "@"
+ result.hashCode() + "\t"
+ (String) result);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}.start();
PhantomReference<String> abcWeakRef = new PhantomReference<String>(abc,
referenceQueue);
abc = null;
Thread.currentThread().sleep(3000);
System.gc();
Thread.currentThread().sleep(3000);
isRun = false;
}
}

</SPAN>

package static_;

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.reflect.Field;

public class Test {
public static boolean isRun = true;

@SuppressWarnings("static-access")
public static void main(String[] args) throws Exception {
String abc = new String("abc");
System.out.println(abc.getClass() + "@" + abc.hashCode());
final ReferenceQueue<String> referenceQueue = new ReferenceQueue<String>();
new Thread() {
public void run() {
while (isRun) {
Object obj = referenceQueue.poll();
if (obj != null) {
try {
Field rereferent = Reference.class
.getDeclaredField("referent");
rereferent.setAccessible(true);
Object result = rereferent.get(obj);
System.out.println("gc will collect："
+ result.getClass() + "@"
+ result.hashCode() + "\t"
+ (String) result);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}.start();
PhantomReference<String> abcWeakRef = new PhantomReference<String>(abc,
referenceQueue);
abc = null;
Thread.currentThread().sleep(3000);
System.gc();
Thread.currentThread().sleep(3000);
isRun = false;
}
}

我们用一个线程检测referenceQueue里面是不是有内容，如果有内容，打印出来queue里面的内容。

从这个例子中，我们可以看出来，虚引用的作用是，我们可以声明虚引用来引用我们感兴趣的对象，在gc要回收的时候，gc收集器会把这个对象添加到referenceQueue，这样我们如果检测到referenceQueue中有我们感兴趣的对象的时候，说明gc将要回收这个对象了。此时我们可以在gc回收之前做一些其他事情，比如记录些日志什么的。

----------------------------------------------分割----------------------------------------------------

感谢蓝大牛分享下面的例子。

在java中，finalize函数本来是设计用来在对象被会瘦的 时候来做一些操作的（类似C++的析构函数）。但是对象被GC什么时候回收的时间，却是不固定的，这样finalize函数很尴尬。虚引用可以用来解决这个问题。

在创建虚引用的时候必须传入一个引用队列。在一个对象的finalize函数被调用之后，这个对象的幽灵引用会被加入到引用队列中。通过检查队列的内容就知道对象是不是要准备被回收了。

幽灵引用的使用并不多见，主要是实现细粒度的内存控制。比如下面代码实现一个缓存。程序在确认原来的对象要被回收之后，才申请内存创建新的缓存。


在上面的代码中，每次申请新的缓存的时候，都要确保之前的字节数组被成功回收。引用队列的remove方法会阻塞直到虚引用被加入到引用队列中。【只有对象在内存中被移除之后才会进入引用队列中】

不过注意，这种方式可能会导致gc次数过多，程序吞吐量下降。

另外注意，system.gc调用仅仅是建议虚拟机进行回收，并不一定马上会进行gc。