Java的四种引用方式

众所周知，Java中是JVM负责内存的分配和回收，这是它的优点（使用方便，程序不用再像使用c那样操心内存），但同时也是它的缺点（不够灵活）。
程序开发时,凌乱的代码会创造大量的对象, 甚至造成JVM抛出OutOfMemoryError错误.

JAVA创建对象的四种方式

强引用，软引用，弱引用，虚引用

Java中提供这四种引用类型主要有两个目的：

第一是可以让程序员通过代码的方式决定某些对象的生命周期；
第二是有利于JVM进行垃圾回收

---

强引用(Strong Reference)

如果一个对象具有强引用，那么垃圾回收器绝对不会回收它，当内存不足时宁愿抛出 OOM（OutOfMemory） 错误，使得程序异常停止。
如:

Object object = new Object();

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

object =null;

软引用(Soft Reference)

用来描述一些还有用但是并非必须的对象，在Java中用java.lang.ref.SoftReference类来表示。垃圾回收器在内存充足的时候不会回收它，而在内存不足时会回收这些对象。

软引用可用来实现内存敏感的高速缓存,比如网页缓存、图片缓存等。使用软引用能防止内存泄露，增强程序的健壮性。

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

demo:

 // 获取对象并缓存
Object object = new Object();
SoftReference softRef = new SoftReference(object);

// 从软引用中获取对象
Object object = (Object) softRef.get();
if (object == null){
    // 当软引用被回收后重新获取对象
    object = new Object();
}

ReferenceQueue

当SoftReference所软引用的对象被垃圾收集器回收的同时，ref所强引用的SoftReference对象被列入ReferenceQueue。也就是说，ReferenceQueue中保存的对象是Reference对象，而且是已经失去了它所软引用的对象的Reference对象。另外从ReferenceQueue这个名字也可以看出，它是一个队列，当我们调用它的poll()方法的时候，如果这个队列中不是空队列，那么将返回队列前面的那个Reference对象。

在任何时候，我们都可以调用ReferenceQueue的poll()方法来检查是否有它所关心的非强可及对象被回收。如果队列为空，将返回一个null,否则该方法返回队列中前面的一个Reference对象。利用这个方法，我们可以检查哪个SoftReference所软引用的对象已经被回收。于是我们可以把这些失去所软引用的对象的SoftReference对象清除掉。常用的方式为:

如:

SoftReference ref = null;  
while ((ref = (SoftReference ) q.poll()) != null) {  
    // 清除ref  
} 

弱引用(Weak Reference)

弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。
在java中，用java.lang.ref.WeakReference类来表示。

如:

WeakReference<String> sr = new WeakReference<String>(new String("hello"));

System.out.println(sr.get());
System.gc();                //通知JVM的gc进行垃圾回收
System.out.println(sr.get());

//结果: hello null

虚引用(Phantom Reference)

虚引用也称为幻影引用：一个对象是都有虚引用的存在都不会对生存时间都构成影响，也无法通过虚引用来获取对一个对象的真实引用。唯一的用处：能在对象被GC时收到系统通知，JAVA中用PhantomReference来实现虚引用。

---

各引用对比图:

---

软引用DEMO

使用软引用模拟一个Employee对象进行缓存的缓存器

class Employee {
    public String id;

    public Employee(String _id) {
        this.id = _id;
    }
}


class EmployeeCache {
    static private EmployeeCache cache;
    private HashMap<String, EmployeeReference> mapEmployeeRefs;
    private ReferenceQueue<Employee> q;


    public static EmployeeCache getInstance() {
        if (cache == null) {
            cache = new EmployeeCache();
        }
        return cache;
    }

    public Employee getEmployee(String id) {
        Employee e = null;
        // 先从缓存中是查找该Employee实例的软引用，如果有，从软引用中取得。
        if (mapEmployeeRefs.containsKey(id)) {
            e = mapEmployeeRefs.get(id).get();
        }

        // 如果没有软引用，或者从软引用中得到的实例是null，重新构建一个实例，
        // 并保存对这个新建实例的软引用
        if (e == null) {
            e = new Employee(id);
            System.out.println("重新生成对象" + id);
            cacheEmployee(e);
        }else{
            System.out.println("从软引用中获取对象" + id);
        }
        return e;
    }

    private void cacheEmployee(Employee e) {
        CleanCache();
        EmployeeReference erf = new EmployeeReference(e, q);
        mapEmployeeRefs.put(e.id, erf);
    }

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

    private class EmployeeReference extends SoftReference<Employee> {
        private String key = "";

        private EmployeeReference(Employee e, ReferenceQueue<Employee> q) {
            super(e, q);
            key = e.id;
        }
    }

    private EmployeeCache() {
        mapEmployeeRefs = new HashMap<>();
        q = new ReferenceQueue<>();
    }

    public static void main(String args[]) {
        EmployeeCache cache = EmployeeCache.getInstance();
        cache.getEmployee("1");
        cache.getEmployee("2");
        cache.getEmployee("3");
        System.gc();
        cache.getEmployee("1");
        cache.getEmployee("2");
    }

}

运行结构:

重新生成对象1
重新生成对象2
重新生成对象3


从软引用中获取对象1
从软引用中获取对象2

注: 部分代码参照 http://www.cnblogs.com/huajiezh/p/5835618.html