理解Java的引用对象

SoftReferenceWeakReference 的特性基本一致， 最大的区别在于 SoftReference会尽可能长的保留引用，不会在GC时就回收对象，而是直到JVM 内存不足时才会被回收(虚拟机保证), 这一特性使得 SoftReference 非常适合缓存应用

http://blog.sina.com.cn/s/blog_8417aea80100skwx.html

      Java 2 平台引入了 java.lang.ref 包，其中包括的类可以让您引用对象，而不将它们留在内存中。这些类还提供了与垃圾收集器（garbage collector）之间有限的交互。

      1.先“由强到弱”（只的是和垃圾回收器的关系）明确几个基本概念：
      strong references是那种你通常建立的reference，这个reference就是强可及的。这个不会被垃圾回收器自动回收。例如：
      StringBuffer buffer = new StringBuffer();
      其中这个buffer就是强引用，之所以称为“强”是取决于它如何处理与Garbage Collector的关系的：它是无论如何都不会被回收的。够强的。强引用在某些时候是有个问题的，下边的一个哈希表实例就是很好的说明。而且还有一个问题就是在缓冲上，尤其是诸如图片等大的结构上。我们在内存中开辟一块区域放置图片缓冲，那我们就希望有个指针指向那块区域。此时若是使用强引用则会强迫图片留在内存，当你觉得不需要的时候你需要手动移除，否则就是内存泄漏。

      WeakReference则类似于可有可无的东西。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存，说白了就是一个没那么strong要求垃圾回收器将一个对象保留在内存中。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。常说的Unreachable和弱引用指代的是一个意思。这可能还是说不清楚，那么我举个例子：
      你有一个类叫做Widget，但是由于某种原因它不能通过继承来添加一项功能。当我们想从这个对象中取出一些信息的时候怎么办呢？假设我们需要监视每个 Widget的serial Number，但是这个Widget却偏偏没有这个属性，而且还不可继承...这时候我们想到了用 HashMaps：serialNumberMap.put(widget, widgetSerialNumber);
       这不就截了嘛~表面上看起来是ok的，但是正是Widget这个Strong Reference产生了问题。当我们设定某个Widget的SerialNumber不需要的时候，那么要从这个映射表中除去这个映射对，否则我们就有了内存泄漏或者是出错（移除了有效的SerialNumber）。这个问题听起来很耳熟，是的，在没有垃圾管理机制的语言中这是个常见问题，在JAVA中我们不用担心。因为我们有WeakReference。我们使用内置的WeakHashMap类，这个类和哈希表HashMap几乎一样，但就是在键 key的地方使用了WeakReference，若一个WeakHashMap key成为了垃圾，那么它对应的入口就会自动被移除。这就解决了上述问题~

      SoftReference则也类似于可有可无的东西。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。

      弱引用与软引用的区别在于：具有WeakReference的对象拥有更短暂的生命周期。或者说SoftReference比WeakReference对回收它所指的对象不敏感。一个WeakReference对象会在下一轮的垃圾回收中被清理，而SoftReference对象则会保存一段时间。SoftReferences并不会主动要求与 WeakReference有什么不同，但是实际上SoftReference对象一般在内存充裕时一般不会被移除，这就是说对于创建缓冲区它们是不错的选择。它兼有了StrongReference和WeakReference的好处，既能停留在内存中，又能在内存不足是去处理，这一切都是自动的！

      PhantomReference为"虚引用"，顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收，也就是说其get方法任何时间都会返回null。虚引用主要用来跟踪对象被垃圾回收的活动。其必须和引用队列（ReferenceQueue）联合使用，这是与弱引用和软引用最大的不同。     

      WeakReference是在垃圾回收活动之前将对象入队的，理论上讲这个对象还可以使用finalize()方法使之重生，但是WeakReference仍然是死掉了。 PhantomReferences对象是在对象从内存中清除出去的时候才入队的。也就是说当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。它限制了finalize()方法的使用，更安全也更高效。

     2.我们看看这个包给我们提供了什么类？
WeakReference 类
WeakReference weakref = new WeakReference(ref);
      这样 weakref 就是 ref 指向对象的一个 weak reference。要引用这个 weak reference 指向的对象可以用 get 方法。把对象的 weak reference 放入 Hashtable 或者缓存中，当没有 strong reference 指向他们的时候，对象就可以被垃圾收集器回收了。实际上，有一个 WeakHashMap 就是专门做这个事的。一旦WeakReference使用get方法返回null的时候，它指向的对象已经变成了垃圾，这个weakref对象也没什么用处了。这就需要有一些清理工作了。而ReferenceQueue类就是做这个的，要是你向ReferenceQueue类传递了一个 WeakReference的构造方法，那么当引用所指的对象成为垃圾时，这个引用的对象就会被自动插入到这个引用队列中。你可以在一定时间间隔内处理这个队列。

SoftReference 类　
     可用来实现智能缓存（java.lang.ref.SoftReference is a relatively new class, used to implement smart caches.）

     假定你有一个对象引用，指向一个大数组：

Object obj = new char[1000000];
     并且如果可能的话，你打算一直保存这个数组，但是如果内存极其短缺的话，你乐于释放这个数组。你可以使用一个
soft reference:
SoftReference ref = new SoftReference(obj);
      Obj是这个soft reference的引用。在以后你用以下的方式检测这个引用：
if (ref.get() == null)// (referent has been cleared)
else// (referent has not been cleared)
       如果这个引用已经被清除了，那么垃圾回收器会收回它所使用的空间，并且你缓存的对象也已经消失。需要注意的是，如果这个指示物还有对它的别的引用，那么垃圾回收器将不会清除它。这个方案可以被用来实现各种不同类型的缓存，这些缓存的特点是只要有可能对象就会被一直保存下来，但是如果内存紧张对象就被清除掉。
      注意：软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

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()); 
}

http://blog.csdn.net/yhmhappy2006/article/details/6731108

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());
	}
}