强引用、软引用、弱引用、虚引用

1 Object object = new Object();  
2 String str = "hello";  

 1 package org.fool.reference;  
 2   
 3 public class StrongReferenceTest {  
 4     public static void main(String[] args) {  
 5         new StrongReferenceTest().test();  
 6     }  
 7   
 8     public void test() {  
 9         /** 
10          * 强引用就是指在程序代码之中普遍存在的，比如下面这段代码中的object和objects都是强引用 
11          * 只要某个对象有强引用与之关联，JVM必定不会回收这个对象，即使在内存不足的情况下， 
12          * JVM宁愿抛出OutOfMemory错误也不会回收这种对象 
13          */  
14         Object object = new Object();  
15         Object[] objects = new Object[100];  
16         /** 
17          * 当运行至Object[] objArr = new Object[100];这句时，如果内存不足，JVM会抛出OOM错误也不会回收object指向的对象。 
18          * 不过要注意的是，当test运行完之后，object和objects都已经不存在了，所以它们指向的对象都会被JVM回收。 
19          * 如果想中断强引用和某个对象之间的关联，可以显示地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。 
20          */  
21     }  
22 }  

 1 package org.fool.reference;  
 2   
 3 import java.lang.ref.SoftReference;  
 4   
 5 public class SoftRefereneceTest {  
 6     public static void main(String[] args) {  
 7         /** 
 8          * 软引用是用来描述一些有用但并不是必需的对象，在Java中用java.lang.ref.SoftReference类来表示。 
 9          * 对于软引用关联着的对象，只有在内存不足的时候JVM才会回收该对象。因此，这一点可以很好地用来解决OOM的问题， 
10          * 并且这个特性很适合用来实现缓存：比如网页缓存、图片缓存等。 
11          * 软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被JVM回收，这个软引用就会被加入到与之关联的引用队列中。 
12          */  
13         SoftReference<String> sr = new SoftReference<>(new String("hello"));  
14           
15         System.out.println(sr.get());   // hello  
16           
17         System.gc();  
18           
19         System.out.println(sr.get());   // hello  
20     }  
21 }

 1 package org.fool.reference;  
 2   
 3 import java.lang.ref.WeakReference;  
 4   
 5 public class WeakReferenceTest {  
 6     public static void main(String[] args) {  
 7         /** 
 8          * 弱引用也是用来描述非必需对象的，当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。 
 9          * 在java中，用java.lang.ref.WeakReference类来表示。 
10          */  
11         WeakReference<String> wr = new WeakReference<>(new String("hello"));  
12           
13         System.out.println(wr.get());   // hello  
14           
15         System.gc();  
16           
17         System.out.println(wr.get());   // null  
18         /** 
19          * 第二个输出结果是null，这说明只要JVM进行垃圾回收，被弱引用关联的对象必定会被回收掉。 
20          * 不过要注意的是，这里所说的被弱引用关联的对象是指只有弱引用与之关联， 
21          * 如果存在强引用同时与之关联，则进行垃圾回收时也不会回收该对象（软引用也是如此）。 
22          * 弱引用可以和一个引用队列（ReferenceQueue）联合使用， 
23          * 如果弱引用所引用的对象被JVM回收，这个软引用就会被加入到与之关联的引用队列中。 
24          */  
25     }  
26 }  

 1 package org.fool.reference;  
 2   
 3 import java.lang.ref.PhantomReference;  
 4 import java.lang.ref.ReferenceQueue;  
 5   
 6 public class PhantomReferenceTest {  
 7     public static void main(String[] args) {  
 8         /** 
 9          * 虚引用和前面的软引用、弱引用不同，它并不影响对象的生命周期。在java中用java.lang.ref.PhantomReference类表示。 
10          * 如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收。 
11          * 要注意的是，虚引用必须和引用队列关联使用，当垃圾回收器准备回收一个对象时， 
12          * 如果发现它还有虚引用，就会把这个虚引用加入到与之 关联的引用队列中。 
13          * 程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。 
14          * 如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。 
15          */  
16           
17         ReferenceQueue<String> queue = new ReferenceQueue<>();  
18   
19         PhantomReference<String> pr = new PhantomReference<>(new String("hello"), queue);  
20       
21         System.out.println(pr.get());   // null  
22           
23         System.gc();  
24           
25         System.out.println(pr.get());   // null  
26     }  
27 }