Java中的四种引用以及ReferenceQueue和WeakHashMap的使用示例

 

简介：

本文主要介绍JAVA中的四种引用： StrongReference(强引用)、SoftReferenc(软引用)、WeakReferenc(弱引用)、PhantomReference(虚引用)的作用。同时我们还将介绍ReferenceQueue和WeakHashMap的功能和使用示例。

 

欢迎探讨，如有错误敬请指正

如需转载，请注明出处 http://www.cnblogs.com/nullzx/

 

---

1. JAVA中的四种引用

四种引用中，软引用、若引用、虚引用都需要相关类来创建。创建的时候都需要传递一个对象，然后通过引用的get方法获取真正的对象。

 

1.1 StrongReference(强引用)

强引用就是我们一般在程序中引用一个对象的方式

Object obj = new Object();

obj就是一个强引用。垃圾回收器绝不会回收它，当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠回收具有强引用的对象来解决内存不足的问题。

 

1.2 SoftReference(软引用)

软引用的创建要借助于java.lang.ref包下的SoftReferenc类。当JVM进行垃圾回收时，只有在内存不足的时候JVM才会回收仅有软引用指向的对象所占的空间。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

package javalearning;   import java.lang.ref.SoftReference; /*  * 虚拟机参数配置  * -Xms256m  * -Xmx1024m */ public class SoftReferenceDemo {     public static void main(String[] args){                   /*软引用对象中指向了一个长度为300000000个元素的整形数组*/         SoftReference<int[]> softReference =                 new SoftReference<int[]>(new int[300000000]);                   /*主动调用一次gc,由于此时JVM的内存够用，此时softReference引用的对象未被回收*/         System.gc();         System.out.println(softReference.get());                   /*消耗内存,会导致一次自动的gc,此时JVM的内存不够用          *就回收softReference对象中指向的数组对象*/         int[] strongReference = new int[100000000];                   System.out.println(softReference.get());     } }

我们应该注意到，上面的代码中名为softReference的引用指向了一个
SoftReference对象，这个指向还是一个强引用类型。而SoftReference对象中指向int类型数组的引用就是一个软引用类型了。

 

运行结果

1 2	[I@2a139a55 null

 

1.3 WeakReference(弱引用)

弱引用的创建要借助于java.lang.ref包下的WeakReferenc类。当JVM进行垃圾回收时，无论内存是否充足，都会回收仅被弱引用关联的对象。由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些被弱引用指向的对象。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

package javalearning;   import java.lang.ref.WeakReference;   public class WeakReferenceDemo {     public static void main(String[] args){           /*若引用对象中指向了一个长度为1000个元素的整形数组*/         WeakReference<String[]> weakReference =                 new WeakReference<String[]>(new String[1000]);                   /*未执行gc,目前仅被弱引用指向的对象还未被回收，所以结果不是null*/              System.out.println(weakReference.get());                   /*执行一次gc,即使目前JVM的内存够用,但还是回收仅被弱引用指向的对象*/         System.gc();         System.out.println(weakReference.get());     } }

同理，上面的代码中名为weakReference的引用指向了一个
WeakReference对象，这个指向还是一个强引用类型。而WeakReference对象中指向String类型数组的引用就是一个弱引用类型了。

运行结果

1 2	[Ljava.lang.String;@2a139a55 null

 

1.4 PlantomReference(虚引用)

如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。创建一个虚引用对象时必须还要传递一个引用队列（ReferenceQueue）。

 

2. ReferenceQueue（引用队列）简介

当gc（垃圾回收线程）准备回收一个对象时，如果发现它还仅有软引用(或弱引用，或虚引用)指向它，就会在回收该对象之前，把这个软引用（或弱引用，或虚引用）加入到与之关联的引用队列（ReferenceQueue）中。如果一个软引用（或弱引用，或虚引用）对象本身在引用队列中，就说明该引用对象所指向的对象被回收了。

当软引用（或弱引用，或虚引用）对象所指向的对象被回收了，那么这个引用对象本身就没有价值了，如果程序中存在大量的这类对象（注意，我们创建的软引用、弱引用、虚引用对象本身是个强引用，不会自动被gc回收），就会浪费内存。因此我们这就可以手动回收位于引用队列中的引用对象本身。

除了上面代码展示的创建引用对象的方式。软、弱、虚引用的创建还有另一种方式，即在创建引用的同时关联一个引用队列。

1 2 3 4 5

SoftReference(T referent, ReferenceQueue<? super T> q)   WeakReference(T referent, ReferenceQueue<? super T> q)   PhantomReference(T referent, ReferenceQueue<? super T> q)

下面的示例中我们利用ReferenceQueue回收SoftReference对象本身。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

package javalearning;   import java.lang.ref.ReferenceQueue; import java.lang.ref.SoftReference;   public class ReferenceQueneDemo {           @SuppressWarnings({ "rawtypes", "unchecked" })     public static void main(String[] args){         /*创建引用队列*/         ReferenceQueue<SoftReference<int[]>> rq =                 new ReferenceQueue<SoftReference<int[]>>();                   /*创建一个软引用数组，每一个对象都是软引用类型*/         SoftReference<int[]>[] srArr = new SoftReference[1000];                   for(int i = 0; i < srArr.length; i++){             srArr[i] = new SoftReference(new int[300000], rq);         }                   /*（可能）在gc前保留下了三个强引用*/         int[] arr1 = srArr[30].get();         int[] arr2 = srArr[60].get();         int[] arr3 = srArr[90].get();                   /*占用内存，会导致一次gc，使得只有软引用指向的对象被回收*/         int[] strongRef = new int[200000000];                   Object x;         int n = 0;         while((x = rq.poll()) != null){             int idx = 0;             while(idx < srArr.length){                 if(x == srArr[idx]){                     System.out.println("free " + x);                     srArr[idx] = null; /*手动释放内存*/                     n++;                     break;                 }                 idx++;             }         }                   /*当然最简单的方法是通过isEnqueued()判断一个软引用方法是否在          * 队列中，上面的方法只是举例          int n = 0;          for(int i = 0; i < srArr.length; i++){             if(srArr[i].isEnqueued()){                 srArr[i] = null;                 n++;             }          }          */              System.out.println("recycle  " + n + "  SoftReference Object");     } }

运行结果（省略部分结果）

1 2 3 4 5 6 7 8 9

…… …… …… free java.lang.ref.SoftReference@cc285f4 free java.lang.ref.SoftReference@55f3ddb1 free java.lang.ref.SoftReference@8bd1b6a free java.lang.ref.SoftReference@18be83e4 free java.lang.ref.SoftReference@cb5822 recycle  997  SoftReference Object

从上面的例子中可以看出，我们回收SoftReference对象的效率并不高。原因是每从队列中取出一个SoftReference引用，就是我们必须和SoftReference[]数组中的每一个对象逐个比较。这样的查找方式显然不及HashMap，所以我们自然想到构建一个引用类型的HashMap来解决这个问题。而实际上JDK中已经提供了一个具有这样功能的类，即WeakHashMap。

 

3. WeakHashMap简介

WeakHahsMap 的实现原理简单来说就是HashMap里面的条目 Entry继承了 WeakReference，那么当 Entry 的 key 不再被使用（即，引用对象不可达）且被 GC 后，那么该 Entry 就会进入到 ReferenceQueue 中。当我们调用WeakHashMap 的get和put方法会有一个副作用，即清除无效key对应的Entry。这个过程就和上面的代码很类似了，首先会从引用队列中取出一个Entry对象，然后在HashMap中查找这个Entry对象的位置，最后把这个 Entry 从 HashMap中删除，这时key和value对象都被回收了。重复这个过程直到队列为空。

最后说明一点，WeakHashMap是线程安全的。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

package javalearning;   import java.util.WeakHashMap;   public class WeakHashMapDemo {     public static void main(String[] args){                   WeakHashMap<String, byte[]> whm = new WeakHashMap<String, byte[]>();         String s1 = new String("s1");         String s2 = new String("s2");         String s3 = new String("s3");                   whm.put(s1, new byte[100]);         whm.put(s2, new byte[100]);         whm.put(s3, new byte[100]);                   s2 = null;         s3 = null;                   /*此时可能还未执行gc,所以可能还可以通过仅有弱引用的key找到value*/         System.out.println(whm.get("s1"));         System.out.println(whm.get("s2"));         System.out.println(whm.get("s3"));                   System.out.println("-------------------");                   /*执行gc,导致仅有弱引用的key对应的entry(包括value)全部被回收*/         System.gc();         System.out.println(whm.get("s1"));         System.out.println(whm.get("s2"));         System.out.println(whm.get("s3"));     } }

运行结果

1 2 3 4 5 6 7

[B@2a139a55 [B@15db9742 [B@6d06d69c ------------------- [B@2a139a55 null null

4. 参考内容

[1] Java中的强引用，软引用，弱引用，虚引用有什么用？

[2] ReferenceQueue的使用

[3] 强软弱虚---强引用、软引用、弱引用、虚引用