标签：des http io os ar 使用 java for strong
Java.lang.ref 是 Java 类库中比较特殊的一个包，它提供了与 Java 垃圾回收器密切相关的引用类。这些引用类对象可以指向其它对象，但它们不同于一般的引用，因为它们的存在并不防碍 Java 垃圾回收器对它们所指向的对象进行回收。其好处就在于使者可以保持对使用对象的引用，同时 JVM 依然可以在内存不够用的时候对使用对象进行回收。因此这个包在用来实现与缓存相关的应用时特别有用。同时该包也提供了在对象的“可达”性发生改变时，进行提醒的机制。本文通过对该包进行由浅入深的介绍与分析，使读者可以加深对该包的理解，从而更好地利用该包进行开发。
我们可以先来看一下 java.lang.ref 这个包的结构，如图 1 所示
该包中各类的继承关系如图 2 所示
Reference 是一个抽象类，而 SoftReference，WeakReference，PhantomReference 以及 FinalReference 都是继承它的具体类。
接下来我们来分别介绍和分析强引用以及 java.lang.ref 包下各种虚引用的特性及用法。
我们都知道 JVM 中对象是被分配在堆（heap）上的，当程序行动中不再有引用指向这个对象时，这个对象就可以被垃圾回收器所回收。这里所说的引用也就是我们一般意义上申明的对象类型的变量（如 String, Object, ArrayList 等），区别于原始数据类型的变量（如 int, short, long 等）也称为强引用。
在了解虚引用之前，我们一般都是使用强引用来对对象进行引用。如：
String tag = new String("T");
此处的 tag 引用就称之为强引用。而强引用有以下特征：
我们要讨论的这三种 Reference 较之于强引用而言都属于“弱引用”，也就是他们所引用的对象只要没有强引用，就会根据条件被 JVM 的垃圾回收器所回收，它们被回收的时机以及用法各不相同。下面分别来进行讨论。
SoftReference 在“弱引用”中属于最强的引用。SoftReference 所指向的对象，当没有强引用指向它时，会在内存中停留一段的时间，垃圾回收器会根据 JVM 内存的使用情况（内存的紧缺程度）以及 SoftReference 的 get() 方法的调用情况来决定是否对其进行回收。（后面章节会用几个实验进行阐述）
具体使用一般是通过 SoftReference 的构造方法，将需要用弱引用来指向的对象包装起来。当需要使用的时候，调用 SoftReference 的 get() 方法来获取。当对象未被回收时 SoftReference 的 get() 方法会返回该对象的强引用。如下：
SoftReference<Bean> bean = new SoftReference<Bean>(new Bean("name", 10));
System.out.println(bean.get());// “name:10”
| 引用类型 | 取得目标对象方式 | 垃圾回收条件 | 是否可能内存泄漏 |
|---|---|---|---|
| 强引用 | 直接调用 | 不回收 | 可能 |
| 软引用 | 视内存情况回收 | 不可能 | |
| 弱引用 | 通过 get() 方法 | 永远回收 | 不可能 |
| 虚引用 | 无法取得 | 不回收 | 可能 |
| 类型 | 是否抛出异常 | 示例代码 | 运行结果 |
|---|---|---|---|
| StrongReference | 抛出异常 | 见清单 6 | Exception in thread "main" java.lang.OutOfMemoryError: Java heap space |
| SoftReference | 不抛异常，之前的引用自动清空并返回 null | 见清单 7 | null |
| WeakReference | 同上 | 见清单 8 | null |
| PhantomReference | 抛出异常 | 见清单 9 | Exception in thread "main" java.lang.OutOfMemoryError: Java heap space |
FinalReference 作为 java.lang.ref 里的一个不能被公开访问的类，又起到了一个什么样的作用呢？作为他的子类， Finalizer 又在垃圾回收机制里扮演了怎么样的角色呢？
实际上，FinalReference 代表的正是 Java 中的强引用，如这样的代码 :
Bean bean = new Bean();
在虚拟机的实现过程中，实际采用了 FinalReference 类对其进行引用。而 Finalizer，除了作为一个实现类外，更是在虚拟机中实现一个 FinalizerThread，以使虚拟机能够在所有的强引用被解除后实现内存清理。
让我们来看看 Finalizer 是如何工作的。首先，通过声明 FinalizerThread，并将该线程实例化，设置为守护线程后，加入系统线程中去。
static {
ThreadGroup tg = Thread.currentThread().getThreadGroup();
for (ThreadGroup tgn = tg;
tgn != null;
tg = tgn, tgn = tg.getParent());
Thread finalizer = new FinalizerThread(tg);
finalizer.setPriority(Thread.MAX_PRIORITY - 2);
finalizer.setDaemon(true);
finalizer.start();
}
在 GC 的过程中，当一个强引用被释放，由系统垃圾收集器标记后的对象，会被加入 Finalizer 对象中的 ReferenceQueue 中去，并调用 Finalizer.runFinalizer() 来执行对象的 finalize 方法。
private void runFinalizer() {
synchronized (this) {
if (hasBeenFinalized()) return;
remove();
}
try {
Object finalizee = this.get();
if (finalizee != null && !(finalizee instanceof java.lang.Enum)) {
invokeFinalizeMethod(finalizee);
/* 注意，这里需要清空栈中包含该变量的的 slot,
** 从而来减少因为一个保守的 GC 实现所造成的变量未被回收的假象 */
finalizee = null;
}
} catch (Throwable x) { }
super.clear();
}
注意，标记处所调用的 invokeFinalizeMethod 为 native 方法，由于 finalize 方法在 Object 类中被声明为 protected，这里必须采用 native 方法才能调用。随后通过将本地强引用设置为空，以便使垃圾回收器清理内存。
可以看到，通过这样的方法，Java 将四种引用对象类型：软引用 (SoftReference)，弱引用 (WeakReference)，强引用 (FinalReference)，虚引用 (PhantomReference) 平等地对待，并在垃圾回收器中进行统一调度和管理。
让我们来回顾一下四种引用类型的表现以及在垃圾回收器回收清理内存时的表现 .
这里比较两个比较典型的 JVM 环境，Oracle Java SE6 和 IBM JDK 6。采用了如下的测试代码 :
public class RefTestObj {
private int id;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public int hashCode() {
return super.hashCode();
}
@Override
public String toString() {
return super.toString() + "[id=" + this.id + "]";
}
@Override
protected void finalize() {
System.out.println("Object [" + this.hashCode() + "][
id=" + this.id + "] come into finalize");
try {
super.finalize();
} catch (Throwable e) {
e.printStackTrace();
}
}
}
import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
public class RefMainThread {
public static void main(String[] args) {
// 创建三种不同的引用类型所需对象
RefTestObj softRef = new RefTestObj();
RefTestObj weakRef = new RefTestObj();
RefTestObj phanRef = new RefTestObj();
softRef.setId(1);
weakRef.setId(2);
phanRef.setId(3);
ReferenceQueue<RefTestObj> softRefQueue = new ReferenceQueue<RefTestObj>();
ReferenceQueue<RefTestObj> weakRefQueue = new ReferenceQueue<RefTestObj>();
ReferenceQueue<RefTestObj> phanRefQueue = new ReferenceQueue<RefTestObj>();
SoftReference<RefTestObj> softRefObj =
new SoftReference<RefTestObj>(softRef, softRefQueue);
WeakReference<RefTestObj> weakRefObj =
new WeakReference<RefTestObj>(weakRef, weakRefQueue);
PhantomReference<RefTestObj> phanRefObj =
new PhantomReference<RefTestObj>(phanRef, phanRefQueue);
// 打印正常情况下三种对象引用
print(softRefObj);
print(weakRefObj);
print(phanRefObj);
// 将对象清空
softRef = null;
weakRef = null;
phanRef = null;
// 打印引用队列及 get() 方法所能取到的对象自身
if (softRefObj != null) {
System.out.println("Soft Reference Object run get():" + softRefObj.get());
System.out.println("Check soft queue:" + softRefQueue.poll());
}
if (weakRefObj != null) {
System.out.println("Weak Reference Object run get():" + weakRefObj.get());
System.out.println("Check weak queue:" + weakRefQueue.poll());
}
if (phanRefObj != null) {
System.out.println("Phantom Reference Object run get():" + phanRefObj.get());
System.out.println("Check Phantom queue:" + phanRefQueue.poll());
}
// 开始执行垃圾回收
System.gc();
System.runFinalization();
// 检查队列，是否已经被加入队列，是否还能取回对象
if (softRefObj != null) {
System.out.println("Soft Reference Object run get():" + softRefObj.get());
System.out.println("Check soft queue:" + softRefQueue.poll());
}
if (weakRefObj != null) {
System.out.println("Weak Reference Object run get():" + weakRefObj.get());
System.out.println("Check weak queue:" + weakRefQueue.poll());
}
if (phanRefObj != null) {
System.out.println("Phantom Reference Object run get():" + phanRefObj.get());
System.out.println("Check Phantom queue:" + phanRefQueue.poll());
}
// 对于虚引用对象，在经过多次 GC 之后， 才会加入到队列中去
Reference<? extends RefTestObj> mynewphan = null;
int refCount = 1;
while (mynewphan == null) {
mynewphan = phanRefQueue.poll();
System.gc();
System.runFinalization();
if (mynewphan != null) {
System.out.println("Check Phantom queue:" + mynewphan);
System.out.println("Count for " + refCount + " times");
break;
}
refCount ++;
}
}
public static void print(Reference<RefTestObj> ref) {
RefTestObj obj = ref.get();
System.out.println("The Reference is " + ref.toString() + " and with object " + obj +
" which is " + (obj == null ? "null" : "not null"));
}
}
通过执行 RefMainThread, 我们可以清晰地根据打印结果看到对象在内存中被加入队列 , 以及调用 finalize 方法的顺序及过程 .
为了测试不同的 JVM 环境并消除其他因素的印象 , 本例采用的背景环境均为 Windows2003 下的 32bit JVM.
首先采用了环境为 Oracle Java SE 6 update 23 进行测试 , 结果如下 :
The Reference is java.lang.ref.SoftReference@c17164 and with object RefTestObj@1fb8ee3[id=1] which is not null The Reference is java.lang.ref.WeakReference@61de33 and with object RefTestObj@14318bb[id=2] which is not null The Reference is java.lang.ref.PhantomReference@ca0b6 and with object null which is null Soft Reference Object run get():RefTestObj@1fb8ee3[id=1] Check soft queue:null Weak Reference Object run get():RefTestObj@14318bb[id=2] Check weak queue:null Phantom Reference Object run get():null Check Phantom queue:null Object [27744459][id=3] come into finalize Object [21174459][id=2] come into finalize Soft Reference Object run get():RefTestObj@1fb8ee3[id=1] Check soft queue:null Weak Reference Object run get():null Check weak queue:java.lang.ref.WeakReference@61de33 Phantom Reference Object run get():null Check Phantom queue:null Check Phantom queue:java.lang.ref.PhantomReference@ca0b6 Count for 2 times
可以看到 , 当运行了系统回收后 , 虚引用与弱引用被回收 , 由于内存并不吃紧 , 软引用依然保持原样 . 弱引用立即被加入了队列 , 而虚引用则在循环两次的手动调用 GC 后被加入了队列 . 其次 , 采用的环境是 IBM JDK 6, 结果如下 :
The Reference is java.lang.ref.SoftReference@3a2c3a2c and with object RefTestObj@391e391e[id=1] which is not null The Reference is java.lang.ref.WeakReference@3a303a30 and with object RefTestObj@39203920[id=2] which is not null The Reference is java.lang.ref.PhantomReference@3a353a35 and with object null which is null Soft Reference Object run get():RefTestObj@391e391e[id=1] Check soft queue:null Weak Reference Object run get():RefTestObj@39203920[id=2] Check weak queue:null Phantom Reference Object run get():null Check Phantom queue:null Object [958544162][id=3] come into finalize Object [958413088][id=2] come into finalize Soft Reference Object run get():RefTestObj@391e391e[id=1] Check soft queue:null Weak Reference Object run get():null Check weak queue:java.lang.ref.WeakReference@3a303a30 Phantom Reference Object run get():null Check Phantom queue:null Object [958282014][id=1] come into finalize ............
程序运行到这里进入了无限循环，必须手动终止。比对上下两份结果可以看到，当多次运行系统垃圾回收后，IBM JVM 将软引用一并加入了回收队列中，并运行了其 finalize 方法。另外，即使经过很多次系统垃圾回收，虚引用也没有被加入到队列中去。不知道这是不是 IBM JVM 的一个小小的 BUG 所在。
本文深入地介绍了 java.lang.ref 包使用方法，并结合实验分析了包内不同类的表现。同时对该包在不同 Java 虚拟机上的表现进行了深入地分析。
原文：http://www.ibm.com/developerworks/cn/java/j-lo-langref/
标签：des http io os ar 使用 java for strong
原文地址：http://www.cnblogs.com/davidwang456/p/4049434.html
