简单直白教你理解Java中四大引用强引用，软引用，弱引用，虚引用

我属于自学型的，所以知识不够系统，只能是一边儿工作一边查漏补缺，在此要对那些写技术文章的人由衷的说句谢谢，谢谢各位大神们的分享

ONE，强引用（StrongReference）

概念介绍：

在此说明一下，StrongReference只是对强引用的一个称呼，但是强引用没有对应的实体类。使用强引用的对象就算是内存出现outofmemory（内存溢出）

的异常也不会回收。也就是说该对象永远不会被垃圾回收器回收，不论内存是否充足。平常代码中用的最多的就是强引用。

Demo验证：

[java]  view plain  copy

 

1.  static Object object = new Object();  
2. ....................................  
3. /** 
4.   * 强引用 
5.   */  
6.  public static void testStrongReference(){  
7.      Object obj = object;  
8.      object = null;  
9.      System.gc();  
10.      System.out.print("after system.gc-strongReference---obj = " + obj);  
11.  }  

输出结果

在该demo中obj就是使用的默认的强引用，虽然obj所指向的对象被置为null,但gc不会回收该强引用对象

TWO，软引用（SoftReference）

概念介绍：

软引用有对应的实体列为SoftReference,使用软引用引用的对象只有在程序发生oom异常前才会回收，也就是说如果内存充足永远不会被回收，只有在内存不足时才会回收，很好的避免oom，非常适合做缓存。

Demo验证

[java]  view plain  copy

 

1. /** 
2.     * 软引用 
3.     */  
4.    public static void testSoftReference(){  
5.   
6.         
7.   
8.       SoftReference<Object> obj = new SoftReference<>(object);  
9.   
10.       object = null;   
11.       System.gc();   
12.       System.out.print("after system.gc---softReference = " + obj); }  

由控制台的输出结果可以看到，虽然软引用引用的对象被清空，但是由于内存充足，就算是执行了gc也不会被回收。

小结一下：由以上的demo可以看到软引用和强引用在内存充足的情况下是一样的都不会被回收，只有在内存不足时软引用才会被及时回收避免oom异常，而强引用却很霸道坚决不回收。这样分析来看，使用软引用可以很好的避免oom异常，适合做一些缓存工作

[java]  view plain  copy

 

1.   

THREE，弱引用（WeakReference）

概念介绍：弱引用对应的实体类为WeakReference，这个概念介绍起来有点儿麻烦，可以参考demo理解再总结

Demo验证：

第一种情况，如果把弱引用所引用的对象置为null，但不进行gc，弱引用的get到的会是null吗？

[java]  view plain  copy

 

1. public static void testWeakReference(){  
2.        WeakReference<Object> weakReference = new WeakReference<Object>(object);  
3.        WeakReference<Object>  weakReferenceStr = new WeakReference<Object>(str);  
4.        object = null;  
5.        str = null;  
6. /        System.gc();  
7.        System.out.println("after system.gc---weakReference = " + weakReference.get());  
8.        System.out.print("after system.gc---weakReferenceStr = " + weakReferenceStr.get());  
9.    }  

输出结果为：

[java]  view plain  copy

 

1. after system.gc---weakReference = java.lang.Object@14ae5a5  
2. after system.gc---weakReferenceStr = strTest  
3. Process finished with exit code 0  

可以看到如果不进行gc，弱引用对象在内存充足的情况下是不会回收的，不论所引用的对象是否为null
第二种情况，不对所引用的对象置为null，直接进行gc

[java]  view plain  copy

 

1.   public static void testWeakReference(){  
2.         WeakReference<Object> weakReference = new WeakReference<Object>(object);  
3.         WeakReference<Object>  weakReferenceStr = new WeakReference<Object>(str);  
4. //        object = null;  
5. //        str = null;  
6.         System.gc();  
7.         System.out.println("after system.gc---weakReference = " + weakReference.get());  
8.         System.out.print("after system.gc---weakReferenceStr = " + weakReferenceStr.get());  
9.     }  

输出结果为

[java]  view plain  copy

 

1. after system.gc---weakReference = java.lang.Object@14ae5a5  
2. after system.gc---weakReferenceStr = strTest  
3. Process finished with exit code 0  

可以看到，此时所引用的对象不为null，所以在进行gc回收时不会回收弱引用对象。由此可以看出弱引用跟对象的生命周期有关，在对象不为null时，垃圾回收器不会回收弱引用

第三种情况

[java]  view plain  copy

 

1. public static void testWeakReference(){  
2.     WeakReference<Object> weakReference = new WeakReference<Object>(object);  
3.     WeakReference<Object>  weakReferenceStr = new WeakReference<Object>(str);  
4.     object = null;  
5.     str = null;  
6.     System.gc();  
7.     System.out.println("after system.gc---weakReference = " + weakReference.get());  
8.     System.out.print("after system.gc---weakReferenceStr = " + weakReferenceStr.get());  
9. }  

输出结果

[java]  view plain  copy

 

1. after system.gc---weakReference = null  
2. after system.gc---weakReferenceStr = strTest  
3. Process finished with exit code 0  

在这里说明一下str对象的定义方式

[java]  view plain  copy

 

1. static String str = "strTest";  

可以看到，使用new的方式构造的对象在置为null后，所对应的弱引用被回收，但是使用赋值的方式所获取的对象置为null后，所对应的弱引用没有被回收，这是为什么呢？这里暂且TODO该问题，把四大引用总结完后再研究

{add 2016-11-15

这是因为gc不清理常量池里的垃圾，所以所引用的内容不为null

}

综合以上三种情况，可以对弱引用下一个结论了，弱应用与对象的生命周期有关。在进行垃圾回收时，如果所引用的对象为null，则不论内存是否充足都会被回收，否则不会被回收。当然当内存不足时会直接被回收。

FOUR，虚引用（PhantonReference）

概念介绍，虚引用对应的实体类为PhantonReference。虚引用不论所引用的对象是不是null，不论内存空间是否充足，都会被垃圾回收器回收

Demo验证

[java]  view plain  copy

 

1.  public static void testPhantonReference(){  
2.         ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();  
3.         PhantomReference<Object> phantomReference = new PhantomReference<>(object,referenceQueue);  
4.         PhantomReference<Object> phantomReferenceStr = new PhantomReference<>(str,referenceQueue);  
5. //        object = null;  
6. //        str = null;  
7.         System.gc();  
8.         System.out.println("after system.gc---phantomReference = " + phantomReference.get());  
9.         System.out.print("after system.gc---phantomReferenceStr = " + phantomReferenceStr.get());  
10.     }  

输出结果如下

[java]  view plain  copy

 

1. after system.gc---phantomReference = null  
2. after system.gc---phantomReferenceStr = null  
3. Process finished with exit code 0
4. 
   
5. 可以看到，只要进行垃圾回收，虚引用就会被回收
6. 总结：
7.   对于垃圾回收器回收的顺序为
8.   虚引用---弱引用----软引用---强引用。
9.   多使用软引用做缓存可以很好地避免oom.  
10.