SoftReferenceWeakReference 的特性基本一致, 最大的区别在于 SoftReference会尽可能长的保留引用,不会在GC时就回收对象,而是直到JVM 内存不足时才会被回收(虚拟机保证), 这一特性使得 SoftReference 非常适合缓存应用
http://blog.sina.com.cn/s/blog_8417aea80100skwx.html
WeakReference 类
WeakReference weakref = new WeakReference(ref);
SoftReference 类
Object obj = new char[1000000];
soft reference:
SoftReference ref = new SoftReference(obj);
if (ref.get() == null)// (referent has been cleared)
else// (referent has not been cleared)
e.g.
import java.lang.ref.*;
public class References
{
public static void main(String[] args)
{
Object weakObj, phantomObj;
Reference ref;
WeakReference weakRef;
PhantomReference phantomRef;
ReferenceQueue weakQueue, phantomQueue;
weakObj = new String("Weak Reference");
phantomObj = new String("Phantom Reference");
weakQueue = new ReferenceQueue();
phantomQueue = new ReferenceQueue();
weakRef = new WeakReference(weakObj, weakQueue);
phantomRef = new PhantomReference(phantomObj, phantomQueue);
// Print referents to prove they exist. Phantom referents
// are inaccessible so we should see a null value.
System.out.println("Weak Reference: " + weakRef.get());
System.out.println("Phantom Reference: " + phantomRef.get());
// Clear all strong references
weakObj = null;
phantomObj = null;
// Invoke garbage collector in hopes that references
// will be queued
System.gc();
// See if the garbage collector has queued the references
System.out.println("Weak Queued: " + weakRef.isEnqueued());
// Try to finalize the phantom references if not already
if (!phantomRef.isEnqueued())
{
System.out.println("Requestion finalization.");
System.runFinalization();
}
System.out.println("Phantom Queued: " + phantomRef.isEnqueued());
// Wait until the weak reference is on the queue and remove it
try
{
ref = weakQueue.remove();
// The referent should be null
System.out.println("Weak Reference: " + ref.get());
// Wait until the phantom reference is on the queue and remove it
ref = phantomQueue.remove();
System.out.println("Phantom Reference: " + ref.get());
// We have to clear the phantom referent even though
// get() returns null
ref.clear();
}
catch (InterruptedException e)
{
e.printStackTrace();
return;
}
}
}
http://www.2cto.com/kf/201009/74414.html
如果你想写一个 Java 程序,观察某对象什么时候会被垃圾收集的执行绪清除,你必须要用一个 reference 记住此对象,以便随时观察,但是却因此造成此对象的 reference 数目一直无法为零, 使得对象无法被清除。
java.lang.ref.WeakReference
不过,现在有了 Weak Reference 之后,这就可以迎刃而解了。如果你希望能随时取得某对象的信息,但又不想影响此对象的垃圾收集,那么你应该用 Weak Reference 来记住此对象,而不是用一般的 reference。
A obj = new A();
WeakReference wr = new WeakReference(obj);
obj = null;
//等待一段时间,obj对象就会被垃圾回收
...
if (wr.get()==null) {
System.out.println("obj 已经被清除了 ");
} else {
System.out.println("obj 尚未被清除,其信息是 " obj.toString());
}
...
在此例中,透过 get() 可以取得此 Reference 的所指到的对象,如果传出值为 null 的话,代表此对象已经被清除。
这类的技巧,在设计 Optimizer 或 Debugger 这类的程序时常会用到,因为这类程序需要取得某对象的信息,但是不可以 影响此对象的垃圾收集。
java.lang.ref.SoftReference
Soft Reference 虽然和 Weak Reference 很类似,但是用途却不同。 被 Soft Reference 指到的对象,即使没有任何 Direct Reference,也不会被清除。一直要到 JVM 内存不足时且 没有 Direct Reference 时才会清除,SoftReference 是用来设计 object-cache 之用的。如此一来 SoftReference 不但可以把对象 cache 起来,也不会造成内存不足的错误 (OutOfMemoryError)。我觉得 Soft Reference 也适合拿来实作 pooling 的技巧。
A obj = new A();
SoftRefenrence sr = new SoftReference(obj);
引用时
if(sr!=null){
obj = sr.get();
}else{
obj = new A();
sr = new SoftReference(obj);
}
http://blog.csdn.net/zhandoushi1982/article/details/8745027
在Java 1.2中就引入了java.lang.ref这个包,WeakReference就属于这个包。WeakReference是干嘛的呢,一言弊之,它是和Java中的垃圾回收相关的。如果一个对象只有WeakReference引用它,那么这个对象就可能被垃圾回收器回收。
在什么场合下应用WeakReference呢?
(1) 有时我们会碰到一些不能继承的类,如final class,无法继承它。假如我们要使用一个Widget类,因为某种缘故无法继承该类来加入某个功能。但是,我们必须将每个Widget对象和某个序列号关联,而Widget本身没有serial number这个属性,这时该怎么做呢?
你也许已经想到,用HashMap:serialNumberMap.put(widget, widgetSerialNumber);这看起来工作的很好。但是有个问题:当我们不再需要某个Widget的serial number信息,此时应该从HashMap中将这个Entry移除,如果我们忘记了怎么办?因为HashMap中持有对这个对象的引用,这个对象永远不会被垃圾回收器回收,这就造成了内存泄漏!这意味着我们需要像没有垃圾回收功能的语言一样,手动管理内存!但是我们用的是Java。
(2)另一个很常见的问题是缓存。如果使用强引用,那么我们缓存的对象就会一直滞留在内存中,不会被回收,除非我们手动的将其从缓存中移除。此外,这还需要我们决定何时从缓存中移除对象,又一个手动管理内存的问题!此时,WeakReference就显示出它的价值了。如何创建一个WeakReference呢?
- WeakReference<widget> weakWidget = newWeakReference<widget>(widget);
- Widget w = weakWidget.get();
要注意的是,当调用weakReference.get()可能返回null(意味着指向的对象已经被回收)。其实,对于Widget serial number这个问题,最简单的方法是使用WeakHashMap,它的使用和普通的HashMap完全一样,不同点在于,WeakHashMap的key被实现为一种WeakReference(注意,是key而不是value),当key对象被回收后,WeakHashMap会自动将对应的entry移除。更精确的说,对于一个给定的键,其映射的存在并不阻止垃圾回收器对该键的回收。
(3)Java中有四种类型的引用,按照强弱关系依次为:Strong Reference>Soft Reference>WeakReference> Phantom Reference。其中,我们平常用的就是Strong Reference,而Phantom Reference很少用到,那么什么是Soft Reference呢?
Soft Reference和weak reference的区别是:一旦gc发现对象是weak reference可达就会把它放到ReferenceQueue中,然后等下次gc时回收它;当对象是Soft reference可达时,gc可能会向操作系统申请更多内存,而不是直接回收它,当实在没辙了才回收它。像cache系统,最适合用Soft reference。让gc来替我们决定什么时候回收对象以及回收哪些对象。差别样例如下:WeakReference的模型
A obj = new A();
WeakReference wr = new WeakReference(obj);
obj = null;
//等待一段时间,obj对象就会被垃圾回收
...
if (wr.get()==null)
{
System.out.println("obj 已经被清除了 ");
} else {
System.out.println("obj 尚未被清除,其信息是 "+obj.toString());
}
package test;
import static junit.framework.Assert.assertFalse;
import static junit.framework.Assert.assertNotNull;
import static junit.framework.Assert.assertNull;
import static junit.framework.Assert.assertSame;
import static junit.framework.Assert.assertTrue;
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;
import java.util.Map;
import java.util.WeakHashMap;
import org.junit.Test;
class VeryBig {
private static final int SIZE = 1000;
private double[] la = new double[SIZE];
private String ident;
public VeryBig(String id) {
ident = id;
}
public VeryBig(String id, int s) {
ident = id;
la = new double[s];
}
public String toString() {
return ident;
}
protected void finalize() {
System.out.println("Finalizing " + ident);
}
}
public class ReferencesTest {
/**
* Strong Reference<br>
* 是 Java 的默认引用实现, 它会尽可能长时间的存活于 JVM 内, 当没有任何强引用指向对象时, GC 执行后将会回收对象
*/
@Test
public void strongReferenceNotGC() {
System.out.println("start test strongReferenceNotGC");
Object referent = new VeryBig("strongReferenceNotGC");
/**
* 通过赋值创建 StrongReference
*/
Object strongReference = referent;
assertSame(referent, strongReference);
referent = null;
System.gc();
/**
* 由于对象还存在引用,因此gc后,对象未被回收
*/
assertNotNull(strongReference);
System.out.println("end test strongReferenceNotGC");
}
@Test
public void strongReferenceGC() throws InterruptedException {
System.out.println("start test strongReferenceGC");
Object referent = new VeryBig("strongReferenceGC");
referent = null;
System.gc();
Thread.sleep(500);
System.out.println("end test strongReferenceGC");
}
/**
* WeakReference<br>
* 顾名思义, 是一个弱引用, 当所引用的对象在 JVM 内不再有强引用时, GC后,弱引用被置成null,并回收所指的对象
*
* @throws InterruptedException
*/
@Test
public void weakReference() throws InterruptedException {
System.out.println("start test weakReference");
WeakReference<Object> weakRerference = new WeakReference<Object>(new VeryBig(
"weakReference"));
System.gc();
Thread.sleep(500);
/**
* weak reference 在 GC 后会被置成null,对象就可以被 回收了。。。
*/
assertNull(weakRerference.get());
System.out.println("end test weakReference");
}
/**
* WeakHashMap<br>
* 使用 WeakReference 作为 key, 一旦没有指向 key 的强引用, WeakHashMap 在 GC 后将自动删除相关的
* entry
*
* @throws InterruptedException
*/
@Test
public void weakHashMap() throws InterruptedException {
Map<Object, Object> weakHashMap = new WeakHashMap<Object, Object>();
Object key = new VeryBig("weakHashMap key");
Object value = new Object();
weakHashMap.put(key, value);
assertTrue(weakHashMap.containsValue(value));
key = null;
System.gc();
/**
* 等待无效 entries 进入 ReferenceQueue 以便下一次调用 getTable 时被清理
*/
Thread.sleep(1000);
/**
* 一旦没有指向 key 的强引用, WeakHashMap 在 GC 后将自动删除相关的 entry
*/
assertFalse(weakHashMap.containsValue(value));
}
/**
* SoftReference<br>
* 与 WeakReference 的特性基本一致, 最大的区别在于
* SoftReference会尽可能长的保留引用,不会在GC时就回收对象,而是直到 JVM 内存不足时才会被回收(虚拟机保证),
* 这一特性使得 SoftReference 非常适合缓存应用
*/
@Test
public void softReference() {
SoftReference<Object> softRerference = new SoftReference<Object>(new VeryBig(
"softReference"));
assertNotNull(softRerference.get());
System.gc();
/**
* soft references 只有在 jvm OutOfMemory 之前才会被回收, 所以它非常适合缓存应用
*/
assertNotNull(softRerference.get());
// make oom....
int i = 0;
while (true) {
try {
++i;
new VeryBig("oom ", 10000000);
} catch (Throwable e) {
System.out.println("OOM after " + i + " times");
e.printStackTrace();
break;
}
}
assertNull(softRerference.get());
}
/**
* PhantomReference<br>
* Phantom Reference(幽灵引用) 与 WeakReference 和 SoftReference 有很大的不同, 因为它的
* get() 方法永远返回 null, 这也正是它名字的由来
*/
@Test
public void phantomReferenceAlwaysNull() {
ReferenceQueue<Object> q = new ReferenceQueue<Object>();
PhantomReference<Object> phantomReference = new PhantomReference<Object>(
new VeryBig("phantomReferenceAlwaysNull"), q);
/**
* phantom reference 的 get 方法永远返回 null
*/
assertNull(phantomReference.get());
assertNull(q.poll());
System.gc();
assertNull(q.poll());
}
/**
* RererenceQueue<br>
* 当一个 WeakReference 开始返回 null 时, 它所指向的对象已经准备被回收, 这时可以做一些合适的清理工作. 将一个
* ReferenceQueue 传给一个 Reference 的构造函数, 当对象被回收时, 虚拟机会自动将这个weak ref插入到
* ReferenceQueue 中, WeakHashMap 就是利用 ReferenceQueue 来清除 key 已经没有强引用的
* entries
*
* @throws InterruptedException
*/
@Test
public void referenceQueueWithWeakReference() throws InterruptedException {
Object referent = new VeryBig("referenceQueueWithWeakReference");
ReferenceQueue<Object> referenceQueue = new ReferenceQueue<Object>();
Reference<Object> ref = new WeakReference<Object>(referent, referenceQueue);
assertFalse(ref.isEnqueued());
Reference<? extends Object> polled = referenceQueue.poll();
assertNull(polled);
referent = null;
System.gc();
assertTrue(ref.isEnqueued());
Reference<? extends Object> removed = referenceQueue.remove();
assertNotNull(removed);
assertSame(ref, removed);
assertNull(removed.get());
}
@Test
public void referenceQueueWithSoftReference() throws InterruptedException {
Object referent = new VeryBig("referenceQueueWithWeakReference");
ReferenceQueue<Object> referenceQueue = new ReferenceQueue<Object>();
Reference<Object> ref = new SoftReference<Object>(referent, referenceQueue);
assertFalse(ref.isEnqueued());
Reference<? extends Object> polled = referenceQueue.poll();
assertNull(polled);
referent = null;
// make oom....
try {
new VeryBig("oom ", 100000000);
} catch (Throwable e) {
}
assertTrue(ref.isEnqueued());
Reference<? extends Object> removed = referenceQueue.remove();
assertNotNull(removed);
assertSame(ref, removed);
assertNull(removed.get());
}
}