【JVM】如何理解强引用、软引用、弱引用、虚引用？

总体架构

强引用

强引用是默认支持，当内存不足的时候，JVM开始垃圾回收，对于强引用的对象，就算是出现了OOM也不会回收对象。

强引用是最多见的普通对象引用，只要还有强引用指向对象，对象就存活，垃圾回收器不会处理存活对象。通常把一个对象赋给一个引用变量，这个引用变量就是强引用。当一个对象被强引用变量所引用，它就处于可达状态，是不会被垃圾回收的，即便以后都不会再用到了，也不会回收。所以强引用是形成Java内存泄漏的主要缘由之一。

关于Java内存泄漏的详细内容，能够参考这篇博客：http://www.javashuo.com/article/p-ppqsozta-dp.html。

对于一个普通对象，若是没有其余引用关系，只要超过了引用的做用域或者显式地将相应的强引用赋值为null，通常认为就是能够被垃圾回收了。（具体的回收时机看垃圾回收策略）

下例中，b就是强引用。

1     public static void main(String[] args) {
2         Object a = new Object();
3         Object b = a;
4         a = null;
5         System.out.println(b);//java.lang.Object@4554617c
6     }

软引用

软引用是一种相对强引用弱化了一些的引用，用java.lang.ref.SoftReference实现，可让对象豁免一些垃圾收集。当系统内存充足的时候，不会被回收；当系统内存不足的时候，会被回收。

软引用通常用于对内存敏感的程序中，好比高速缓存。

 1 import java.lang.ref.SoftReference;
 2 
 3 public class SoftReferenceDemo {
 4     public static void main(String[] args) {
 5         Object a = new Object();
 6         SoftReference<Object> softReference = new SoftReference<>(a);//软引用
 7         //a和软引用指向同一个对象
 8         System.out.println(a);//java.lang.Object@4554617c
 9         System.out.println(softReference.get());//java.lang.Object@4554617c
10 
11         //内存够用，软引用不会被回收
12         a = null;
13         System.gc();//内存够用不会自动gc，手动唤醒gc
14         System.out.println(a);//null
15         System.out.println(softReference.get());//java.lang.Object@4554617c
16 
17         //内存不够用时
18         try{
19             //配置Xms和Xmx为5MB
20             byte[] bytes = new byte[1024*1024*30];//设置30MB超内存
21         }catch (Throwable e){
22             e.printStackTrace();
23         }finally {
24             System.out.println(a);//null
25             System.out.println(softReference.get());//null
26         }
27     }
28 }

使用场景

一个应用须要读取大量的本地图片，若是每次读取都从硬盘读取会严重影响性能，若是一次性所有加载到内存，内存可能会溢出。

可使用软引用解决这个问题，使用一个HashMap来保存图片路径和图片对象管理的软引用之间的映射关系，内存不足时，JVM会自动回收缓存图片对象的占用空间，有效地避免了OOM（Out Of Memory）问题。

Map<String, SoftReference<Bitmap>> imageCache = new HashMap<String, SoftReference<Bitmap>>

弱引用

弱引用须要用java.lang.ref.WeakReference实现，它比软引用的生存期更短，对于弱引用的对象来讲，只要垃圾回收机制一运行，无论JVM的内存空间是否够，都会回收该对象的占用内存。

 1 import java.lang.ref.WeakReference;
 2 
 3 public class SoftReferenceDemo {
 4     public static void main(String[] args) {
 5         Object a = new Object();
 6         WeakReference<Object> softReference = new WeakReference<>(a);//软引用
 7         //a和弱引用指向同一个对象
 8         System.out.println(a);//java.lang.Object@4554617c
 9         System.out.println(softReference.get());//java.lang.Object@4554617c
10 
11         //内存够用，弱引用也会被回收
12         a = null;
13         System.gc();//内存够用不会自动gc，手动唤醒gc
14         System.out.println(a);//null
15         System.out.println(softReference.get());//null
16     }
17 }

关于WeakHashMap

 1     public static void weakHashMapTest() {
 2         Integer key = new Integer(1);
 3         String value = "李四";
 4         Map<Integer,String> weakHashMap = new WeakHashMap();
 5         weakHashMap.put(key, value);
 6         System.out.println(weakHashMap);//{1=李四}
 7         key = null;
 8         System.gc();
 9         System.out.println(weakHashMap);//{}
10     }
11 
12     public static void hashMapTest() {
13         HashMap<Integer,String> map = new HashMap<>();
14         Integer key = 1;
15         String value = "张三";
16         map.put(key,value);
17         System.out.println(map);//{1=张三}
18         key = null;
19         System.gc();
20         System.out.println(map);//{1=张三}
21     }

在HashMap中，键被置为null，唤醒gc后，不会垃圾回收键为null的键值对。可是在WeakHashMap中，键被置为null，唤醒gc后，键为null的键值对会被回收。

虚引用

虚引用要经过java.lang.ref.PhantomReference类来实现，虚引用不会决定对象的生命周期，若是一个对象只有虚引用，就至关于没有引用，在任什么时候候均可能会被垃圾回收器回收。它不能单独使用也不能访问对象，虚引用必须和引用队列联合使用。

虚引用的主要做用是跟踪对象被垃圾回收的状态，仅仅是提供一种确保对象被finalize之后，作某些事情的机制。

PhantomReference的get方法老是返回null，所以没法访问对应的引用对象，设置虚引用关联惟一的目的是在对象被收集器回收的时候收到一个系统通知，或者后续添加进一步的处理。Java容许使用finalize()方法在垃圾回收器将对象从内存中清理出去以前作一些必要的清理工做。【例如实现一个监控对象的通知机制】

引用队列

WeakReference和ReferenceQueue的联合使用效果：

 1     public static void weakReferenceTest() {
 2         Object a = new Object();
 3         ReferenceQueue<Object> queue = new ReferenceQueue<>();
 4         WeakReference<Object> weakReference = new WeakReference<>(a,queue);
 5         System.out.println(a);//java.lang.Object@4554617c
 6         System.out.println(weakReference.get());//java.lang.Object@4554617c
 7         System.out.println(queue.poll());//null
 8         System.out.println("-------------------");
 9         a = null;
10         System.gc();
11         System.out.println(a);//null
12         System.out.println(weakReference.get());//null
13         //虚引用在回收以前被加入到了引用队列中
14         System.out.println(queue.poll());//java.lang.ref.WeakReference@74a14482
15     }

PhantomReference和ReferenceQueue的联合使用效果：

 1     public static void phantomReferenceTest() {
 2         Object a = new Object();
 3         ReferenceQueue<Object> queue = new ReferenceQueue<>();
 4         PhantomReference<Object> phantomReference = new PhantomReference<>(a,queue);
 5         System.out.println(a);//java.lang.Object@4554617c
 6         System.out.println(phantomReference.get());//null
 7         System.out.println(queue.poll());//null
 8         System.out.println("-------------------");
 9         a = null;
10         System.gc();
11         System.out.println(a);//null
12         System.out.println(phantomReference.get());//null
13         //引用在回收以前被加入到了引用队列中
14         System.out.println(queue.poll());//java.lang.ref.WeakReference@74a14482
15     }

总结

强引用：不回收。

软引用：内存不够就回收。

弱引用：必定回收。

虚引用：必定回收，get出来就是null，引用形同虚设，主要和引用队列联合使用，在finalize以前会被放到引用队列中。

与根对象没有引用关系的：引用不可达，必定回收。