SoftReference、WeakReference和PhantomRefrence分析和比较

本文将谈一下对SoftReference(软引用)、WeakReference(弱引用)和PhantomRefrence(虚引用)的理解三各类理解,这三个类是对heap中java对象的应用,通过这个三个类可以和gc做简单的交互. 

引用种类

除了上面提到的三个引用之外,还有一个引用,也就是最长用到的那就是强引用.例如

Java代码

1. 1.Object o=new Object();    
   
2. 2.Object o1=o;   
   
3. Object o=new Object();
   
4. Object o1=o;

复制代码

上面代码中第一句是在heap堆中创建新的Object对象通过o引用这个对象,第二句是通过o建立o1到new Object()这个heap堆中的对象的引用,这两个引用都是强引用.只要存在对heap中对象的引用,gc就不会收集该对象.如果通过如下代码

Java代码

1. 1.o=null;    
   
2. 2.o1=null;   
   
3. o=null;
   
4. o1=null;

复制代码

显示的设置o和o1为null,或超出范围,则gc认为该对象不存在引用,就可以搜集它了.可以收集,并不等于就一会被收集.什么时候收集这要取决于gc的算法.这要就带来很对不一定性.例如你就想指定一个对象，希望下次gc运行时把它收集了，那就没办法了，有了其他的三种引用就可以做到了。其他的三种引用在不妨碍gc收集的情况下,可以做简单的交互.heap中对象有强可及对象、软可及对象、弱可及对象、虚可及对象和不可到达对象。应用的强弱顺序是强、软、弱、和虚。对于对象是属于哪种可及的对象，由他的最强的引用决定。如下

Java代码

1. 1.String abc=new String("abc");  //1    
   
2. 2.SoftReference<String> abcSoftRef=new SoftReference<String>(abc);  //2    
   
3. 3.WeakReference<String> abcWeakRef = new WeakReference<String>(abc); //3    
   
4. 4.abc=null; //4    
   
5. 5.abcSoftRef.clear();//5   
   
6. String abc=new String("abc");  //1
   
7. SoftReference<String> abcSoftRef=new SoftReference<String>(abc);  //2
   
8. WeakReference<String> abcWeakRef = new WeakReference<String>(abc); //3
   
9. abc=null; //4
   
10. abcSoftRef.clear();//5

复制代码

上面的代码中

    第一行在heap对中创建内容为“abc”的对象，并建立abc到该对象的强引用,该对象是强可及的

    第二行和第第三行分别建立对heap中对象的软引用和弱引用,此时heap中的对象仍是强可及的.

    第四行之后heap中对象不再是强可及的,变成软可及的,同样第五行执行之后变成弱可及的.

  SoftReference(软引用)

   软引用是主要用于内存敏感的高速缓存.在jvm报告内存不足之前,会清楚所有的软引用,这样以来gc就有可能收集软可及的对象,可能解决内存吃紧问题,避免内存溢出.什么时候会被收集,取决于gc的算法和gc运行时可用内存的大小.当gc决定要收集软引用是执行以下过程,以上面的abcSoftRef为例.

    1 首先将abcSoftRef的referent设置为null,不在引用heap中的new String("abc")对象.

    2 将heap中的new String("abc")对象设置为可结束的(finalizable).

    3 当heap中的new String("abc")对象的finalize()方法被运行而且该对象占用的内存被释放， abcSoftRef被添加到它的ReferenceQueue中.

   注:对ReferenceQueue软引用和如引用可以有可无,但是虚引用必须有.见



Java代码

1. 1.Reference(T paramT, ReferenceQueue<? super T>paramReferenceQueue)   
   
2. Reference(T paramT, ReferenceQueue<? super T>paramReferenceQueue)   WeakReference(弱引用)
   

复制代码

当gc碰到弱可及对象,并释放abcWeakRef 的对的引用,收集该对象.但是gc可能需要对此运用才能找到该若可及对象.通过如下代码可以了明了的看出它的作用.

Java代码

1. 1.String abc=new String("abc");    
   
2. 2.WeakReference<String> abcWeakRef = new WeakReference<String>(abc);    
   
3. 3.abc=null;    
   
4. 4.System.out.println("before gc: "+abcWeakRef.get());    
   
5. 5.System.gc();    
   
6. 6.System.out.println("after gc: "+abcWeakRef.get());    
   
7. 7.   
   
8. 8.运行结果:    
   
9. 9.before gc: abc    
   
10. 10.after gc: null   
    
11. String abc=new String("abc");
    
12. WeakReference<String> abcWeakRef = new WeakReference<String>(abc);
    
13. abc=null;
    
14. System.out.println("before gc: "+abcWeakRef.get());
    
15. System.gc();
    
16. System.out.println("after gc: "+abcWeakRef.get());

复制代码

运行结果:
before gc: abc
after gc: null   当gc收集弱可及对象,执行过程和软可及一样,只是gc不会根据内存情况来决定是不是收集该对象.

   PhantomRefrence(虚引用)

  虚顾名思义就是没有的意思,建立虚引用之后通过get方法返回结果始终为null,通过源代码你会发现,虚引用通向会把引用的对象写进referent,只是get方法返回结果为null.先看一下和gc交互的过程在说一下他的作用.

  1 不把referent设置为null,直接把heap中的new String("abc")对象设置为可结束的(finalizable).

  2 与软引用和弱引用不同,先把PhantomRefrence对象添加到它的ReferenceQueue中.然后在释放虚可及的对象. 

   你会发现在收集heap中的new String("abc")对象之前,你就可以做一些其他的事情.通过以下代码可以了解他的作用.

    

Java代码

1. 1.import java.lang.ref.PhantomReference;    
   
2. 2.import java.lang.ref.Reference;    
   
3. 3.import java.lang.ref.ReferenceQueue;    
   
4. 4.import java.lang.reflect.Field;    
   
5. 5.   
   
6. 6.public class Test {    
   
7. 7.    public static boolean isRun = true;    
   
8. 8.   
   
9. 9.    public static void main(String[] args) throws Exception {    
   
10. 10.        String abc = new String("abc");    
    
11. 11.        System.out.println(abc.getClass() + "@" + abc.hashCode());    
    
12. 12.        final ReferenceQueue referenceQueue = new ReferenceQueue<String>();    
    
13. 13.        new Thread() {    
    
14. 14.            public void run() {    
    
15. 15.                while (isRun) {    
    
16. 16.                    Object o = referenceQueue.poll();    
    
17. 17.                    if (o != null) {    
    
18. 18.                        try {    
    
19. 19.                            Field rereferent = Reference.class   
    
20. 20.                                    .getDeclaredField("referent");    
    
21. 21.                            rereferent.setAccessible(true);    
    
22. 22.                            Object result = rereferent.get(o);    
    
23. 23.                            System.out.println("gc will collect:"   
    
24. 24.                                    + result.getClass() + "@"   
    
25. 25.                                    + result.hashCode());    
    
26. 26.                        } catch (Exception e) {    
    
27. 27.   
    
28. 28.                            e.printStackTrace();    
    
29. 29.                        }    
    
30. 30.                    }    
    
31. 31.                }    
    
32. 32.            }    
    
33. 33.        }.start();    
    
34. 34.        PhantomReference<String> abcWeakRef = new PhantomReference<String>(abc,    
    
35. 35.                referenceQueue);    
    
36. 36.        abc = null;    
    
37. 37.        Thread.currentThread().sleep(3000);    
    
38. 38.        System.gc();    
    
39. 39.        Thread.currentThread().sleep(3000);    
    
40. 40.        isRun = false;    
    
41. 41.    }    
    
42. 42.   
    
43. 43.}   
    
44. import java.lang.ref.PhantomReference;
    
45. import java.lang.ref.Reference;
    
46. import java.lang.ref.ReferenceQueue;
    
47. import java.lang.reflect.Field;
    
48. public class Test {
    
49. public static boolean isRun = true;
    
50. public static void main(String[] args) throws Exception {
    
51. String abc = new String("abc");
    
52. System.out.println(abc.getClass() + "@" + abc.hashCode());
    
53. final ReferenceQueue referenceQueue = new ReferenceQueue<String>();
    
54. new Thread() {
    
55. public void run() {
    
56. while (isRun) {
    
57. Object o = referenceQueue.poll();
    
58. if (o != null) {
    
59. try {
    
60. Field rereferent = Reference.class
    
61. .getDeclaredField("referent");
    
62. rereferent.setAccessible(true);
    
63. Object result = rereferent.get(o);
    
64. System.out.println("gc will collect:"
    
65. + result.getClass() + "@"
    
66. + result.hashCode());
    
67. } catch (Exception e) {
    
68. e.printStackTrace();
    
69. }
    
70. }
    
71. }
    
72. }
    
73. }.start();
    
74. PhantomReference<String> abcWeakRef = new PhantomReference<String>(abc,
    
75. referenceQueue);
    
76. abc = null;
    
77. Thread.currentThread().sleep(3000);
    
78. System.gc();
    
79. Thread.currentThread().sleep(3000);
    
80. isRun = false;
    
81. }
    
82. }