Java中的强引用、软引用、弱引用和虚引用

本文为阅读下面四篇博文的读书笔记
http://sishuok.com/forum/blogPost/list/342.html
http://blog.sae.sina.com.cn/archives/5228?utm_source=tuicool
http://www.cnblogs.com/dolphin0520/p/3784171.html
http://blog.csdn.net/arui319/article/details/8489451

四种引用的前世今生

Java 在设计之初就希望 Java 开发者不需要像使用 C/C++ 开发时，需要考虑内存管理的问题，所以就提供了垃圾回收器和一切都是对象两个办法减轻开发者的负担。所以在 JDK 1.2 以前的版本中，当一个对象不被任何变量引用，程序将无法使用该对象，因为它已经被回收了。换句话说，只有对象处于可触及状态，才能存活，供程序使用。但这样做存在问题：因为有时候你确实在一段时间内不需要使用这个对象，但如果有突发情况发生时，你又需要使用它了，如果对象的构建成本很高的话，对象被垃圾回收器回收就会带来许多麻烦。

所以为了让开发者能够通过代码决定某些对象的生命周期，以及利于 JVM 的垃圾回收，Java 从 JDK 1.2 版本开始，就将 Java 对象的引用分为四种级别，从而使程序能更加灵活的控制对象的生命周期。这四种级别由高到低依次为：强引用、软引用、弱引用和虚引用。

四种引用的概念

强引用

强引用就是我们平常使用对象的方式，例如下面的 object 和 str 都是强引用：

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

那么强引用有什么作用呢？如果一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空间不足，JVM 也不会回收它，而是抛出 OutOfMemoryError 错误，使程序异常终止。例如下面的代码：

public class Main {
    public static void main(String[] args) {
        new Main().fun1();
    }

    public void fun1() {
        Object object = new Object();
        Object[] objArr = new Object[1000];
    }
}

当运行至Object[] objArr = new Object[1000];这句时，如果内存不足，JVM会抛出OOM错误也不会回收object指向的对象。不过要注意的是，当fun1运行完之后，object和objArr都已经不存在了，所以它们指向的对象都会被JVM回收。

但如果想中断强引用和某个对象之间的关联，可以显式地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。

比如Vector类的clear方法中就是通过将引用赋值为null来实现清理工作的：

/**
     * Removes the element at the specified position in this Vector.
     * Shifts any subsequent elements to the left (subtracts one from their
     * indices).  Returns the element that was removed from the Vector.
     *
     * @throws ArrayIndexOutOfBoundsException if the index is out of range
     *         ({@code index < 0 || index >= size()})
     * @param index the index of the element to be removed
     * @return element that was removed
     * @since 1.2
     */
    public synchronized E remove(int index) {
    modCount++;
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);
    Object oldValue = elementData[index];

    int numMoved = elementCount - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                 numMoved);
    elementData[--elementCount] = null; // Let gc do its work

    return (E)oldValue;
    }

软引用

软引用通过 SoftReference 创建，在使用软引用时，如果内存的空间足够，软引用就能继续被使用，而不会被垃圾回收器回收，只有在内存不足时，软引用才会被垃圾回收器回收。

软引用的这种特性使得它很适合用来解决 OOM 问题，实现缓存机制，例如：图片缓存、网页缓存等等……

软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被JVM回收，这个软引用就会被加入到与之关联的引用队列中。

弱引用

事实上软引用和弱引用非常类似，两者的区别在于：只具有弱引用的对象拥有的生命周期更短暂。因为当 JVM 进行垃圾回收，一旦发现弱引用对象，无论当前内存空间是否充足，都会将弱引用回收。不过由于垃圾回收器是一个优先级较低的线程，所以并不一定能迅速发现弱引用对象。

弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被JVM回收，这个弱引用就会被加入到与之关联的引用队列中。

虚引用

“虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会影响对象的生命周期。如果一个对象仅持有虚引用，那么它相当于没有引用，在任何时候都可能被垃圾回收器回收。

那虚引用有什么用？虚引用主要用来跟踪对象被垃圾回收的活动。这是什么意思呢？

public class Main {
    public static void main(String[] args) {
        ReferenceQueue<String> queue = new ReferenceQueue<String>();
        PhantomReference<String> pr = new PhantomReference<String>(new String("hello"), queue);
        System.out.println(pr.get());
    }
}

假设你现在持有一个 String——”hello” 的虚引用 pr，那么当垃圾回收器回收 hello 的时候，就会把虚引用放入引用队列 queue 之中，然后完成回收。简单来说，就是让你知道对象被回收了。

所以我们可以知道，虚引用和其他几种引用不同的地方在于：虚引用必须和引用队列关联使用，当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会把这个虚引用加入到与之 关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

实际应用场景

一、利用软引用和弱引用解决OOM问题

前面讲了关于软引用和弱引用相关的基础知识，那么到底如何利用它们来优化程序性能，从而避免OOM的问题呢？

下面举个例子，假如有一个应用需要读取大量的本地图片，如果每次读取图片都从硬盘读取，则会严重影响性能，但是如果全部加载到内存当中，又有可能造成内存溢出，此时使用软引用可以解决这个问题。

设计思路是：用一个HashMap来保存图片的路径 和 相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占用的空间，从而有效地避免了OOM的问题。在Android开发中对于大量图片下载会经常用到。

下面这段代码是摘自博客：

http://blog.csdn.net/arui319/article/details/8489451

.....
private Map<String, SoftReference<Bitmap>> imageCache = new HashMap<String, SoftReference<Bitmap>>();
<br>....
public void addBitmapToCache(String path) {

        // 强引用的Bitmap对象

        Bitmap bitmap = BitmapFactory.decodeFile(path);

        // 软引用的Bitmap对象

        SoftReference<Bitmap> softBitmap = new SoftReference<Bitmap>(bitmap);

        // 添加该对象到Map中使其缓存

        imageCache.put(path, softBitmap);

    }

 public Bitmap getBitmapByPath(String path) {

        // 从缓存中取软引用的Bitmap对象

        SoftReference<Bitmap> softBitmap = imageCache.get(path);

        // 判断是否存在软引用

        if (softBitmap == null) {

            return null;

        }

        // 取出Bitmap对象，如果由于内存不足Bitmap被回收，将取得空

        Bitmap bitmap = softBitmap.get();

        return bitmap;

    }

二、使用软引用构建敏感数据的缓存

SoftReference的特点是它的一个实例保存对一个Java对象的软引用，该软引用的存在不妨碍垃圾收集线程对该Java对象的回收。也就是说，一旦SoftReference保存了对一个Java对象的软引用后，在垃圾线程对这个Java对象回收前，SoftReference类所提供的get()方法返回Java对象的强引用。另外，一旦垃圾线程回收该Java对象之后，get()方法将返回null。

MyObject aRef = new MyObject();   
SoftReference aSoftRef=new SoftReference(aRef); 

此时，对于这个MyObject对象，有两个引用路径，一个是来自SoftReference对象的软引用，一个来自变量aReference的强引用，所以这个MyObject对象是强可及对象。

随即，我们可以结束aReference对这个MyObject实例的强引用:

 aRef = null; 

此后，这个MyObject对象成为了软可及对象。如果垃圾收集线程进行内存垃圾收集，并不会因为有一个SoftReference对该对象的引用而始终保留该对象。Java虚拟机的垃圾收集线程对软可及对象和其他一般Java对象进行了区别对待:软可及对象的清理是由垃圾收集线程根据其特定算法按照内存需求决定的。也就是说，垃圾收集线程会在虚拟机抛出OutOfMemoryError之前回收软可及对象，而且虚拟机会尽可能优先回收长时间闲置不用的软可及对象，对那些刚刚构建的或刚刚使用过的“新”软可反对象会被虚拟机尽可能保留。在回收这些对象之前，我们可以通过:

 MyObject anotherRef=(MyObject)aSoftRef.get(); 

重新获得对该实例的强引用。而回收之后，调用get()方法就只能得到null了。

三、通过软可及对象重获方法实现Java对象的高速缓存

public class Employee {    
    private String id;// 雇员的标识号码    
    private String name;// 雇员姓名    
    private String department;// 该雇员所在部门    
    private String Phone;// 该雇员联系电话    
    private int salary;// 该雇员薪资    
    private String origin;// 该雇员信息的来源    

    // 构造方法    
    public Employee(String id) {    
       this.id = id;    
       getDataFromlnfoCenter();    
    }    

    // 到数据库中取得雇员信息    
    private void getDataFromlnfoCenter() {    
       // 和数据库建立连接井查询该雇员的信息，将查询结果赋值    
       // 给name，department，plone，salary等变量    
       // 同时将origin赋值为"From DataBase"    
    }    
……    

这个Employee类的构造方法中我们可以预见，如果每次需要查询一个雇员的信息。哪怕是几秒中之前刚刚查询过的，都要重新构建一个实例，这是需要消耗很多时间的。下面是一个对Employee对象进行缓存的缓存器的定义:

import java.lang.ref.ReferenceQueue;    
import java.lang.ref.SoftReference;    
import java.util.Hashtable;    
public class EmployeeCache {    
    static private EmployeeCache cache;// 一个Cache实例    
    private Hashtable employeeRefs;// 用于Cache内容的存储    
    private ReferenceQueue q;// 垃圾Reference的队列    

    // 继承SoftReference，使得每一个实例都具有可识别的标识。    
    // 并且该标识与其在HashMap内的key相同。    
    private class EmployeeRef extends SoftReference {    
       private String _key = "";    

       public EmployeeRef(Employee em, ReferenceQueue q) {    
           super(em, q);    
           _key = em.getID();    
       }    
    }    

    // 构建一个缓存器实例    
    private EmployeeCache() {    
       employeeRefs = new Hashtable();    
       q = new ReferenceQueue();    
    }    

    // 取得缓存器实例    
    public static EmployeeCache getInstance() {    
       if (cache == null) {    
           cache = new EmployeeCache();    
       }    
       return cache;    
    }    

    // 以软引用的方式对一个Employee对象的实例进行引用并保存该引用    
    private void cacheEmployee(Employee em) {    
       cleanCache();// 清除垃圾引用    
       EmployeeRef ref = new EmployeeRef(em, q);    
       employeeRefs.put(em.getID(), ref);    
    }    

    // 依据所指定的ID号，重新获取相应Employee对象的实例    
    public Employee getEmployee(String ID) {    
       Employee em = null;    
       // 缓存中是否有该Employee实例的软引用，如果有，从软引用中取得。    
       if (employeeRefs.containsKey(ID)) {    
           EmployeeRef ref = (EmployeeRef) employeeRefs.get(ID);    
           em = (Employee) ref.get();    
       }    
       // 如果没有软引用，或者从软引用中得到的实例是null，重新构建一个实例，    
       // 并保存对这个新建实例的软引用    
       if (em == null) {    
           em = new Employee(ID);    
           System.out.println("Retrieve From EmployeeInfoCenter. ID=" + ID);    
           this.cacheEmployee(em);    
       }    
       return em;    
    }    

    // 清除那些所软引用的Employee对象已经被回收的EmployeeRef对象    
    private void cleanCache() {    
       EmployeeRef ref = null;    
       while ((ref = (EmployeeRef) q.poll()) != null) {    
           employeeRefs.remove(ref._key);    
       }    
    }    

    // 清除Cache内的全部内容    
    public void clearCache() {    
       cleanCache();    
       employeeRefs.clear();    
       System.gc();    
       System.runFinalization();    
    }    
}    

四、使用弱引用构建非敏感数据的缓存

无意识对象保留最常见的原因是使用Map将元数据与临时对象（transient object）相关联。假定一个对象具有中等生命周期，比分配它的那个方法调用的生命周期长，但是比应用程序的生命周期短，如客户机的套接字连接。需要将一些元数据与这个套接字关联，如生成连接的用户的标识。在创建Socket时是不知道这些信息的，并且不能将数据添加到Socket对象上，因为不能控制 Socket 类或者它的子类。这时，典型的方法就是在一个全局 Map 中存储这些信息，如下面的 SocketManager 类所示：使用一个全局 Map 将元数据关联到一个对象。

public class SocketManager {    
    private Map<SOCKET,USER> m = new HashMap<SOCKET,USER>();    

    public void setUser(Socket s, User u) {    
       m.put(s, u);    
    }    

    public User getUser(Socket s) {    
       return m.get(s);    
    }    

    public void removeUser(Socket s) {    
       m.remove(s);    
    }    
}    

这种方法的问题是元数据的生命周期需要与套接字的生命周期挂钩，但是除非准确地知道什么时候程序不再需要这个套接字，并记住从 Map 中删除相应的映射，否则，Socket 和 User 对象将会永远留在 Map 中，远远超过响应了请求和关闭套接字的时间。这会阻止 Socket 和 User 对象被垃圾收集，即使应用程序不会再使用它们。这些对象留下来不受控制，很容易造成程序在长时间运行后内存爆满。除了最简单的情况，在几乎所有情况下找出什么时候 Socket 不再被程序使用是一件很烦人和容易出错的任务，需要人工对内存进行管理。

在Java集合中有一种特殊的Map类型—WeakHashMap，在这种Map中存放了键对象的弱引用，当一个键对象被垃圾回收器回收时，那么相应的值对象的引用会从Map中删除。WeakHashMap能够节约存储空间，可用来缓存那些非必须存在的数据。关于Map接口的一般用法。

下面示例中MapCache类的main()方法创建了一个WeakHashMap对象，它存放了一组Key对象的弱引用，此外main()方法还创建了一个数组对象，它存放了部分Key对象的强引用。

import java.util.WeakHashMap;    

class Element {    
    private String ident;    

    public Element(String id) {    
       ident = id;    
    }    

    public String toString() {    
       return ident;    
    }    

    public int hashCode() {    
       return ident.hashCode();    
    }    

    public boolean equals(Object obj) {    
       return obj instanceof Element && ident.equals(((Element) obj).ident);    
    }    

    protected void finalize(){    
       System.out.println("Finalizing "+getClass().getSimpleName()+" "+ident);    
    }    
}    

class Key extends Element{    
    public Key(String id){    
       super(id);    
    }    
}    

class Value extends Element{    
    public Value (String id){    
       super(id);    
    }    
}    

public class CanonicalMapping {    
    public static void main(String[] args){    
       int size=1000;    
       Key[] keys=new Key[size];    
       WeakHashMap map=new WeakHashMap();    
       for(int i=0;i< SPAN>  
           Key k=new Key(Integer.toString(i));    
           Value v=new Value(Integer.toString(i));    
           if(i%3==0)    
              keys[i]=k;    
           map.put(k, v);    
       }    
       System.gc();    
    }    
}    

从打印结果可以看出，当执行System.gc()方法后，垃圾回收器只会回收那些仅仅持有弱引用的Key对象。id可以被3整除的Key对象持有强引用，因此不会被回收。

在 SocketManager 中防止泄漏很容易，只要用 WeakHashMap 代替 HashMap 就行了。（这里假定SocketManager不需要线程安全）。当映射的生命周期必须与键的生命周期联系在一起时，可以使用这种方法。用WeakHashMap修复 SocketManager。

public class SocketManager {    
    private Map m = new WeakHashMap();    

    public void setUser(Socket s, User u) {    
        m.put(s, u);    
    }    
    public User getUser(Socket s) {    
        return m.get(s);    
    }    
}