从 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());
// 通知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.");
// 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;
}
