Java 引用 详解

从 Java SE2 开始，就提供了四种类型的引用 : 强引用、软引用、弱引用和虚引用。Java中提供这四种引用类型主要有两个目的 : 第一是可以让程序员通过代码的方式决定某些对象的生命周期；第二是有利于 JVM 进行垃圾回收

1> 强引用 : 强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。当内存空间不足，JVM 宁愿抛出OutOfMemoryError 错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题

// test对象未消亡之前，object和str都是强引用

public class test {

    Object object = new Object();

    String str = "hello";

}

2> 软引用 : 如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。软引用可以和一个引用队列 (ReferenceQueue) 联合使用，如果软引用所引用的对象被垃圾回收器回收，JVM 就会把这个软引用加入到与之关联的引用队列中

import java.lang.ref.SoftReference;

public class Main {

    public static void main(String[] args) {

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

        System.out.println(sr.get());

    }

}

3> 弱引用 : 弱引用与软引用的区别在于，只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。弱引用可以和一个引用队列 (ReferenceQueue) 联合使用，如果弱引用所引用的对象被垃圾回收，JVM 就会把这个弱引用加入到与之关联的引用队列中

import java.lang.ref.WeakReference;

public class Main {

    public static void main(String[] args) {

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

        System.out.println(sr.get());

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

        System.out.println(sr.get());

    }

}

4> 虚引用 : “虚引用” 顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于 : 虚引用必须和引用队列 (ReferenceQueue) 联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中

import java.lang.ref.PhantomReference;

import java.lang.ref.ReferenceQueue;

public class Main {

    public static void main(String[] args) {

        ReferenceQueue<String> queue = new ReferenceQueue<>();

        PhantomReference<String> pr = new PhantomReference<>(new String("hello"), queue);

        System.out.println(pr.get());

    }

}

程序可以通过判断引用队列中是否已经加入虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动

引用队列 ReferenceQueue : 就是一个引用队列，如果保存的是 Reference 对象本身，如果 Reference 引用指向的对象被 GC回收，其实 Reference 已经无效，这种 Reference 将被放入引用队列，可以在这里将其清除，避免占有空间

import java.lang.ref.Reference;

import java.lang.ref.ReferenceQueue;

import java.lang.ref.WeakReference;

public class ReferenceQueueTest {

    public static void main(String[] args) {

        final ReferenceQueue q = new ReferenceQueue();

        String str = "test";

        WeakReference wr = new WeakReference(str, q);

        Thread t = new Thread(() -> {

            try {

                Reference reference = q.remove();

                System.out.println(reference + " event fired.");

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        });

        t.setDaemon(true);

        t.start();

        System.out.println("Reference Queue is listening.");

        str = null; // clear strong reference

        System.out.println("Ready to gc");

        System.gc();

        try {

            Thread.sleep(2000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        System.out.println("wr.get: " + wr.get());

    }

}

WeakHashMap : 弱引用 map 就是 key键 是一个弱引用的键，如果 key键 被回收，则在get该map中值后，会自动 remove 掉 value。如果 key键 始终被强引用，则是无法被回收的；这个适合于受 key 生命周期控制的缓存

注 : value 是被强引用的，所以不要让 value 间接的引用 key键，这将导致 key 始终被强引用

import java.util.HashMap;

import java.util.Map;

import java.util.WeakHashMap;

public class WeakHashMapTest {

    public static void main(String[] args) {

        String test = "test";

        String tmp = "tmp";

        WeakHashMap weakmap = new WeakHashMap();

        Map map = new HashMap();

        map.put(test, "test");

        map.put(tmp, "tmp");

        weakmap.put(test, "test");

        weakmap.put(tmp, "tmp");

        map.remove(test);

        // 清除强引用

        test = null;

        tmp = null;

        System.gc();

        // map:tmp:tmp

        for (Object o : map.entrySet()) {

            Map.Entry en = (Map.Entry) o;

            System.out.println("map:" + en.getKey() + ":" + en.getValue());

        }

        // weakmap:tmp:tmp

        // weakmap:test:test

        for (Object o : weakmap.entrySet()) {

            Map.Entry en = (Map.Entry) o;

            System.out.println("weakmap:" + en.getKey() + ":" + en.getValue());

        }

    }

}

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

private Map<String, SoftReference<Bitmap>> imageCache = new HashMap<String, SoftReference<Bitmap>>();

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;

}