标签：
从JDK1.2版本开始，把对象的引用分为四种级别，从而使程序能更加灵活的控制对象的生命周期。这四种级别由高到低依次为：强引用、软引用、弱引用和虚引用。虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃 圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是 否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
在java.lang.ref包中提供了三个类：SoftReference类、WeakReference类和PhantomReference 类，它 们分别代表软引用、弱引用和虚引用。ReferenceQueue类表示引用队列，它可以和这三种引用类联合使用，以便跟踪Java虚拟机回收所引用的对
象的活动。以下程序创建了一个String对象、ReferenceQueue对象和WeakReference对象：
//创建一个强引用
String str = new String("hello");
//创建引用队列, <String>为范型标记，表明队列中存放String对象的引用
ReferenceQueue<String> rq = new ReferenceQueue<String>();
//创建一个弱引用，它引用"hello"对象，并且与rq引用队列关联
//<String>为范型标记，表明WeakReference会弱引用String对象
WeakReference<String> wf = new WeakReference<String>(str, rq);
以上程序代码执行完毕，内存中引用与对象的关系如图11-10所示。
图11-10 "hello"对象同时具有强引用和弱引用
在图11-10中，带实线的箭头表示强引用，带虚线的箭头表示弱引用。从图中可以看出，此时"hello"对象被str强引用，并且被一个WeakReference对象弱引用，因此"hello"对象不会被垃圾回收。
在以下程序代码中，把引用"hello"对象的str变量置为null，然后再通过WeakReference弱引用的get()方法获得"hello"对象的引用：
String str = new String("hello"); //①
ReferenceQueue<String> rq = new ReferenceQueue<String>(); //②
WeakReference<String> wf = new WeakReference<String>(str, rq); //③
str=null; //④取消"hello"对象的强引用
String str1=wf.get(); //⑤假如"hello"对象没有被回收，str1引用"hello"对象
//假如"hello"对象没有被回收，rq.poll()返回null
Reference<? extends String> ref=rq.poll(); //⑥
执行完以上第④行后，内存中引用与对象的关系如图11-11所示，此 时"hello"对象仅仅具有弱引用，因此它有可能被垃圾回收。假如它还没有被垃圾回收，那么接下来在第⑤行执行wf.get()方法会返 回"hello"对象的引用，并且使得这个对象被str1强引用。再接下来在第⑥行执行rq.poll()方法会返回null，因为此时引用队列中没有任 何引用。ReferenceQueue的poll()方法用于返回队列中的引用，如果没有则返回null。
图11-11 "hello"对象只具有弱引用
在以下程序代码中，执行完第④行后，"hello"对象仅仅具有弱引用。接下来两次调用System.gc()方法，催促垃圾回收器工作，从而提 高"hello"对象被回收的可能性。假如"hello"对象被回收，那么WeakReference对象的引用被加入到ReferenceQueue
中，接下来wf.get()方法返回null，并且rq.poll()方法返回WeakReference对象的引用。图11-12显示了执行完第⑧行后 内存中引用与对象的关系。
String str = new String("hello"); //①
ReferenceQueue<String> rq = new ReferenceQueue<String>(); //②
WeakReference<String> wf = new WeakReference<String>(str, rq); //③
str=null; //④
//两次催促垃圾回收器工作，提高"hello"对象被回收的可能性
System.gc(); //⑤
System.gc(); //⑥
String str1=wf.get(); //⑦ 假如"hello"对象被回收，str1为null
Reference<? extends String> ref=rq.poll(); //⑧
图11-12 "hello"对象被垃圾回收，弱引用被加入到引用队列
下面是我的相关测试代码：
package dhp;
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.util.Map;
import java.util.WeakHashMap;
public class Ref {
public Ref() {
}
/**
* @param args
*/
public static void main(String[] args) {
try {
//test1();
//test2();
//test3();
//test4();
//test5();
//test6();
//test7();
test8();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/** 强引用，JVM的默认实现 */
public static void test1() throws InterruptedException {
Object obj = new Object();
Object strong = obj;
obj = null;
System.gc();
Thread.sleep(1000);
System.out.println("strong="+strong);
/**
* strong=java.lang.Object@1b8d6f7
*/
}
/**
* WeakReference 弱引用( 当所引用的对象在 JVM 内不再有强引用时, GC 后weak reference 将会被自动回收)
* */
public static void test2() throws InterruptedException {
Object obj = new Object();
WeakReference<Object> wr = new WeakReference<Object>(obj);
obj = null;
System.gc();
Thread.sleep(1000);
System.out.println("wr.get()="+wr.get());
System.out.println("wr="+wr);
wr.clear();
System.out.println("w1111r="+wr.get());
/**
* wr.get()=null
wr=java.lang.ref.WeakReference@1b8d6f7
w1111r=null
*/
}
/**
* SoftReference SoftReference 于 WeakReference 的特性基本一致， 最大的区别在于
* SoftReference 会尽可能长的保留引用直到 JVM 内存不足时才会被回收(虚拟机保证)
* */
public static void test3() throws InterruptedException {
Object obj = new Object();
SoftReference<Object> sr = new SoftReference<Object>(obj);
obj = null;
System.gc();
Thread.sleep(1000);
System.out.println("sr.get()="+sr.get());
/**
* sr.get()=java.lang.Object@16dadf9
*/
}
/**
* PhantomReference Phantom Reference(幽灵引用) 与 WeakReference 和 SoftReference
* 有很大的不同, 因为它的 get() 方法永远返回 null
* */
public static void test4() throws InterruptedException {
Object obj = new Object();
ReferenceQueue<Object> rq = new ReferenceQueue<Object>();
PhantomReference<Object> pr = new PhantomReference<Object>(obj, rq);
System.out.println("pr.get()="+pr.get());
/**
* pr.get()=null
*/
}
/**
* ReferenceQueue：
* @throws InterruptedException
*/
public static void test5() throws InterruptedException {
Object obj = new Object();
ReferenceQueue<Object> rq = new ReferenceQueue<Object>();
WeakReference<Object> pr = new WeakReference<Object>(obj, rq);
System.out.println("**pr.enqueue()="+pr.enqueue());
System.out.println("**pr.isEnqueued()="+pr.isEnqueued());
System.out.println("**pr="+pr);
System.out.println("**rq.poll()="+rq.poll());
obj = null;
System.out.println("=======================");
System.gc();
System.out.println("pr.enqueue()="+pr.enqueue());
System.out.println("**pr.isEnqueued()="+pr.isEnqueued());
System.out.println("pr="+pr);
System.out.println("rq.poll()="+rq.poll());
System.out.println("obj5="+obj);
/**
* **pr.enqueue()=true
**pr.isEnqueued()=true
**pr=java.lang.ref.WeakReference@1833eca
**rq.poll()=java.lang.ref.WeakReference@1833eca
=======================
pr.enqueue()=false
**pr.isEnqueued()=false
pr=java.lang.ref.WeakReference@1833eca
rq.poll()=null
obj5=null
*/
}
/**
* 使用 WeakReference 作为 key， 一旦没有指向 key 的强引用,
* WeakHashMap 在 GC 后将自动删除相关的
* entry
*/
public static void test6() throws InterruptedException {
Map<Object, Object> map = new WeakHashMap<Object, Object>();
Object key = new Object();
Object value = new Object();
map.put(key, value);
key = null;
// System.out.println("value="+value);
// System.out.println("key="+key);
// System.out.println("map.containsValue(value)="+map.containsValue(value));
// System.out.println("map="+map);
System.gc();
Thread.sleep(1000);
System.out.println("value="+value);
System.out.println("key="+key);
System.out.println("map.containsValue(value)="+map.containsValue(value));
System.out.println("map="+map);
}
public static void test7() throws InterruptedException {
String str = new String("hello"); //①
ReferenceQueue<String> rq = new ReferenceQueue<String>(); //②
WeakReference<String> wf = new WeakReference<String>(str, rq); //③
str=null; //④取消"hello"对象的强引用
String str1=wf.get(); //⑤假如"hello"对象没有被回收，str1引用"hello"对象
//假如"hello"对象没有被回收，rq.poll()返回null
System.out.println(rq.poll()); //⑥
}
public static void test8() throws InterruptedException {
String str = new String("hello"); //①
ReferenceQueue<String> rq = new ReferenceQueue<String>(); //②
WeakReference<String> wf = new WeakReference<String>(str, rq); //③
str=null; //④取消"hello"对象的强引用
//两次催促垃圾回收器工作，提高"hello"对象被回收的可能性
System.gc(); //⑤
System.gc(); //⑥
System.gc();
System.gc();
System.gc();
for (int i = 0; i < 10; i++) {
System.gc();
}
String str1=wf.get(); //⑦ 假如"hello"对象被回收，str1为null
System.out.println(rq.poll());
}
}
标签：
原文地址：http://blog.csdn.net/victor_cindy1/article/details/44727153
