【转】Java之WeakReference与SoftReference使用讲解

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.

Java代码1.import java.lang.ref.*;  2. 3.public class References {  4.  public static void main(String[] args) {  5.    Object weakObj, phantomObj;  6.    Reference ref;  7.    WeakReference weakRef;  8.    PhantomReference phantomRef;  9.    ReferenceQueue weakQueue, phantomQueue;  10. 11.    weakObj    = new String("Weak Reference");  12.    phantomObj = new String("Phantom Reference");  13.    weakQueue    = new ReferenceQueue();  14.    phantomQueue = new ReferenceQueue();  15.    weakRef    = new WeakReference(weakObj, weakQueue);  16.    phantomRef = new PhantomReference(phantomObj, phantomQueue);  17. 18.    // Print referents to prove they exist.  Phantom referents  19.    // are inaccessible so we should see a null value.  20.    System.out.println("Weak Reference: " + weakRef.get());  21.    System.out.println("Phantom Reference: " + phantomRef.get());  22. 23.    // Clear all strong references  24.    weakObj    = null;  25.    phantomObj = null;  26. 27.    // Invoke garbage collector in hopes that references  28.    // will be queued  29.    System.gc();  30. 31.    // See if the garbage collector has queued the references  32.    System.out.println("Weak Queued: " + weakRef.isEnqueued());  33.    // Try to finalize the phantom references if not already  34.    if(!phantomRef.isEnqueued()) {  35.      System.out.println("Requestion finalization.");  36.      System.runFinalization();  37.    }  38.    System.out.println("Phantom Queued: " + phantomRef.isEnqueued());  39. 40.    // Wait until the weak reference is on the queue and remove it  41.    try {  42.      ref = weakQueue.remove();  43.      // The referent should be null  44.      System.out.println("Weak Reference: " + ref.get());  45.      // Wait until the phantom reference is on the queue and remove it  46.      ref = phantomQueue.remove();  47.      System.out.println("Phantom Reference: " + ref.get());  48.      // We have to clear the phantom referent even though  49.      // get() returns null  50.      ref.clear();  51.    } catch(InterruptedException e) {  52.      e.printStackTrace();  53.      return;  54.    }  55.  }  56.}