java强引用、 SoftReference 、 WeakReference 和 PhantomReference的区别

强引用,任何时候都不会被;垃圾回收器回收,如果内存不足,宁愿抛出OutOfMemoryError

软引用,只有在内存将满的时候才会被垃圾回收器回收,如果还有可用内存,垃圾回收器不会回收

弱引用,只要垃圾回收器运行,就肯定会被回收,不管还有没有可用内存。

 

虚引用,虚引用等于没有引用,任何时候都有可能被垃圾回收。

 

我们知道java语言提供了4种引用类型:强引用、软引用(SoftReference)、弱引用(WeakReference)和幽灵引用(PhantomReference),与引用密切相关的,还有一个引用队列ReferenceQueue。引用和引用队列的关系,对于垃圾回收来说非常重要,学习垃圾回收机制,必须要先了解引用和引用队列的使用方法。本文主要参考网上的一些理论,同时配合自己的一些测试代码,更好的理解这些概念。这篇博客也解决了 System.gc()和-XX:+DisableExplicitGC启动参数,以及DirectByteBuffer的内存释放  中遗留的幽灵引用的问题。

 

1、强引用

     强引用不会被GC回收,并且在java.lang.ref里也没有实际的对应类型,平时工作接触的最多的就是强引用。
  Object obj = new Object();这里的obj引用便是一个强引用。如果一个对象具有强引用,那就类似于必不可少的生活用品,垃圾回收器绝不会回收它。当内存空 间不足,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足问题。

 

2、软引用

如果一个对象只具有软引用,那就类似于可有可物的生活用品。如果内存空间足够,垃圾回收器就不会回收它,如果内存空间不足了,就会回收这些对象的内存。只 要垃圾回收器没有回收它,该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。 软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收,Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

 

[java]   view plain copy
  1. /** 
  2.  * 只有当内存不够的时候,才回收这类内存,因此在内存足够的时候,它们通常不被回收 
  3.  *  
  4.  * 
     
  5.  * 无论是否发送GC,执行结果都是: 
  6.  * java.lang.Object@f9f9d8 
  7.  * null 
  8.  * java.lang.Object@f9f9d8 
  9.  * null 
  10.  *  
  11.  *  
  12.  * 可以看到:只有发送了GC,将对于从内存中释放的时候,JVM才会将reference假如引用队列 
  13.  */  
  14. public static void soft() throws Exception  
  15. {  
  16.     Object obj = new Object();  
  17.     ReferenceQueue refQueue = new ReferenceQueue();  
  18.     SoftReference softRef = new SoftReference(obj, refQueue);  
  19.     System.out.println(softRef.get()); // java.lang.Object@f9f9d8  
  20.     System.out.println(refQueue.poll());// null  
  21.   
  22.     // 清除强引用,触发GC  
  23.     obj = null;  
  24.     System.gc();  
  25.   
  26.     System.out.println(softRef.get());  
  27.   
  28.     Thread.sleep(200);  
  29.     System.out.println(refQueue.poll());  
  30. }  
  31. 这里有几点需要说明:

     

    1、System.gc()告诉JVM这是一个执行GC的好时机,但具体执不执行由JVM决定(事实上这段代码一般都会执行GC)

    2、Thread.sleep(200); 这是因为从对象被回收到JVM将引用加入refQueue队列,需要一定的时间。而且poll并不是一个阻塞方法,如果没有数据会返回null,所以我们选择等待一段时间。

     

    3、弱引用

    如果一个对象只具有弱引用,那就类似于可有可物的生活用品。弱引用与软引用的区别在于:只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。不过,由于垃圾回收器是一个优先级很低的线程, 因此不一定会很快发现那些只具有弱引用的对象。  弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被垃圾回 收,Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。 

    [java]   view plain copy
    1. /** 
    2.  * 弱引用: 当发生GC的时候,Weak引用对象总是会内回收回收。因此Weak引用对象会更容易、更快被GC回收。 
    3.  * Weak引用对象常常用于Map数据结构中,引用占用内存空间较大的对象 
    4.  *  
    5.  * 
       
    6.  * 如果不发生垃圾回收:  
    7.  * java.lang.Object@f9f9d8  
    8.  * null  
    9.  * java.lang.Object@f9f9d8 
    10.  * null 
    11.  *  
    12.  * 如果发生垃圾回收: 
    13.  * java.lang.Object@f9f9d8 
    14.  * null 
    15.  * null 
    16.  * java.lang.ref.WeakReference@422ede 
    17.  *  
    18.  * 
       
    19.  */  
    20. public static void weak() throws Exception  
    21. {  
    22.     Object obj = new Object();  
    23.     ReferenceQueue refQueue = new ReferenceQueue();  
    24.     WeakReference weakRef = new WeakReference(obj, refQueue);  
    25.     System.out.println(weakRef.get()); // java.lang.Object@f9f9d8  
    26.     System.out.println(refQueue.poll());// null  
    27.   
    28.     // 清除强引用,触发GC  
    29.     obj = null;  
    30.     System.gc();  
    31.   
    32.     System.out.println(weakRef.get());  
    33.   
    34.     // 这里特别注意:poll是非阻塞的,remove是阻塞的.  
    35.     // JVM将弱引用放入引用队列需要一定的时间,所以这里先睡眠一会儿  
    36.     // System.out.println(refQueue.poll());// 这里有可能是null  
    37.   
    38.     Thread.sleep(200);  
    39.     System.out.println(refQueue.poll());  
    40.     // System.out.println(refQueue.poll());//这里一定是null,因为已经从队列中移除  
    41.   
    42.     // System.out.println(refQueue.remove());  
    43. }  
    44. 这里需要注意下:

       

      1、remove这是一个阻塞方法,类似于J.U.C并发包下的阻塞队列,如果没有队列没有数据,那么当前线程一直等待。

      2、如果队列有数据,那么remove和pool都会将第一个元素出队。

      4、幽灵引用(虚引用)

      虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于:虚引用必须和引用队列 (ReferenceQueue)联合使用。当垃圾回收器回收一个对象时,如果发现它还有虚引用,就会把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用,来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。由于Object.finalize()方法的不安全性、低效性,常常使用虚引用完成对象回收前的资源释放工作。参考我的另一篇博客:解释为什么finalize是不安全的,不建议使用

       

      [java]   view plain copy
      1. /** 
      2.  * 当GC一但发现了虚引用对象,将会将PhantomReference对象插入ReferenceQueue队列. 
      3.  * 而此时PhantomReference所指向的对象并没有被GC回收,而是要等到ReferenceQueue被你真正的处理后才会被回收. 
      4.  *  
      5.  * 
         
      6.  * 不发生GC执行结果是: 
      7.  * null 
      8.  * null 
      9.  * null 
      10.  * null 
      11.  *  
      12.  * 发生GC执行结果是: 
      13.  * null 
      14.  * null 
      15.  * null 
      16.  * java.lang.ref.PhantomReference@87816d 
      17.  *  
      18.  *  
      19.  * 虚引用在实现一个对象被回收之前必须做清理操作是很有用的,比finalize()方法更灵活 
      20.  */  
      21. public static void phantom() throws Exception  
      22. {  
      23.     Object obj = new Object();  
      24.     ReferenceQueue refQueue = new ReferenceQueue();  
      25.     PhantomReference phantom = new PhantomReference(obj,  
      26.             refQueue);  
      27.     System.out.println(phantom.get()); // java.lang.Object@f9f9d8  
      28.     System.out.println(refQueue.poll());// null  
      29.   
      30.     obj = null;  
      31.     System.gc();  
      32.   
      33.     // 调用phanRef.get()不管在什么情况下会一直返回null  
      34.     System.out.println(phantom.get());  
      35.   
      36.     // 当GC发现了虚引用,GC会将phanRef插入进我们之前创建时传入的refQueue队列  
      37.     // 注意,此时phanRef所引用的obj对象,并没有被GC回收,在我们显式地调用refQueue.poll返回phanRef之后  
      38.     // 当GC第二次发现虚引用,而此时JVM将phanRef插入到refQueue会插入失败,此时GC才会对obj进行回收  
      39.     Thread.sleep(200);  
      40.     System.out.println(refQueue.poll());  
      41. }  
      42. 这里特别需要注意:当JVM将虚引用插入到引用队列的时候,虚引用执行的对象内存还是存在的。但是PhantomReference并没有暴露API返回对象。如NIO直接内存的自动回收,就使用到了sun.misc.Cleaner

         

        [java]   view plain copy
        1. public class Cleaner extends PhantomReference  
        2. {  
        3. }  

        JDK底层源码查询网站:http://www.docjar.com/html/api/sun/misc/Cleaner.java.html

         

        5、小结

        引用和引用队列提供了一种通知机制,允许我们知道对象已经被销毁或者即将被销毁。GC要回收一个对象的时候,如果发现该对象有软、弱、虚引用的时候,会将这些引用加入到注册的引用队列中。软引用和弱引用差别不大,JVM都是先把SoftReference和WeakReference中的referent字段值设置成null,之后加入到引用队列;而虚引用则不同,如果某个堆中的对象,只有虚引用,那么JVM会将PhantomReference加入到引用队列中,JVM不会自动将referent字段值设置成null。

         

        参考资料:

         

        Java:对象的强、软、弱和虚引用    http://zhangjunhd.blog.51cto.com/113473/53092/

        Java 中的 Reference              http://www.cnblogs.com/newcj/archive/2011/05/15/2046882.html

        你可能感兴趣的:(java强引用、 SoftReference 、 WeakReference 和 PhantomReference的区别)