Java 强引用、软引用、弱引用、虚引用
1、杂谈
在Java中，虽然不需要程序员手动去管理对象的生命周期，但是如果希望某些对象具备一定的生命周期的话（比如内存不足时JVM就会自动回收某些对象从而避免OutOfMemory的错误）就需要用到软引用和弱引用了。
从JDK1.2版本开始，把对象的引用分为四种级别，从而使程序能更加灵活的控制对象的生命周期。这四种级别由高到低依次为：强引用、软引用、弱引用和虚引用。
Java中提供这四种引用类型主要有两个目的：
第一是可以让程序员通过代码的方式决定某些对象的生命周期；
第二是有利于JVM进行垃圾回收。
2、详解
1）强引用
我们使用的大部分引用其实都是强引用，这是在我们的开发工作当中普遍存在的。
如果一个对象具有强引用，jvm的垃圾回收器也不会回收它。
当内存空间不足的时候，java虚拟机宁可抛出OOM异常，也不会回收具有强引用的对象来释放内存。
我们可以将对象显示的赋值为null，则gc认为该对象不存在引用，这时就可以回收这个对象。具体什么时候收集这要取决于gc的算法。
我们来看下Arraylist中的clear方法
/**
* Removes all of the elements from this list. The list will
* be empty after this call returns.
*/
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
这里看到Arraylist的clear方法其实是把整个list中的所有对象都赋值成了null，然后就等到GC回收了。
2）软引用
软引用是用来描述一些有用但并不是必需的对象，在 Java 中用 java.lang.ref.SoftReference 类来表示。
对于软引用关联着的对象，只有在内存不足的时候JVM才会回收该对象。
如果一个对象只有软引用，就类似鸡肋，食之无味、弃之可惜，如果内存空间足够大，垃圾回收期就不会回收它，如果内存空间不够了，就会回收这些对象。只要垃圾回收器没有回收它，该对象就可以被程序使用。
这个特性很适合用来实现缓存：比如网页缓存、图片缓存等。
软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，java虚拟机会把这个软引用加入到与之关联的 引用队列 中。
创建对象，建立软引用：
SoftReference<User> ref = new SoftReference<User>(new User(1, "songhk"));
上面的代码，等价于下面的三行代码
//上面的一行代码，等价于下面的三行代码
User u1 = new User(1,"songhk"); // 这是 强引用
SoftReference<User> ref = new SoftReference<User>(u1); // 这个是软引用
u1 = null; // 必须u1=null，否则就是 强引用，不是软引用
/**
* 软引用的测试：内存不足即回收
* -Xms10m -Xmx10m
*
* -Xms10m -Xmx10m -XX:+PrintGCDetails
*/
public class SoftReferenceTest {
public static class User {
public User(int id, String name) {
this.id = id;
this.name = name;
}
public int id;
public String name;
@Override
public String toString() {
return "[id=" + id + ", name=" + name + "] ";
}
}
public static void main(String[] args) {
//创建对象，建立软引用
// SoftReference ref = new SoftReference(new User(1, "songhk"));
//上面的一行代码，等价于如下的三行代码
User u1 = new User(1,"songhk"); // 这是 强引用
SoftReference<User> ref = new SoftReference<User>(u1); //这个是软引用
u1 = null;//必须u1=null，否则就是强引用
//从软引用中重新获得强引用对象
System.out.println(ref.get());
System.gc();
System.out.println("After GC:");
// //垃圾回收之后获得软引用中的对象
System.out.println(ref.get());//由于堆空间内存足够，所有不会回收软引用的可达对象。
//
try {
//让系统认为内存资源紧张、不够
byte[] b = new byte[1024 * 1024 * 7];
// byte[] b = new byte[1024 * 7168 - 635 * 1024];
} catch (Throwable e) {
e.printStackTrace();
} finally {
//再次从软引用中获取数据
System.out.println(ref.get());//在报OOM之前，垃圾回收器会回收软引用的可达对象。
}
}
}
运行结果：
[id=1, name=songhk]
After GC:
[id=1, name=songhk]
[id=1, name=songhk]
当内存足够大时可以把数组存入软引用，取数据时就可从内存里取数据，提高运行效率。
软引用在实际中有重要的应用，例如浏览器的后退按钮，这个后退时显示的网页内容可以重新进行请求或者从缓存中取出：
（1）如果一个网页在浏览结束时就进行内容的回收，则按后退查看前面浏览过的页面时，需要重新构建
（2）如果将浏览过的网页存储到内存中会造成内存的大量浪费，甚至会造成内存溢出这时候就可以使用软引用
3）弱引用
弱引用也是用来描述 非必需的对象，只被 弱引用关联的对象，只能生存到下一次垃圾收集发生为止。 当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。在java中，用 java.lang.ref.WeakReference 类来表示。
弱引用 和 软引用 的区别在于：弱引用 的对象具有更短暂的生命周期。软引用 关联的对象只有在内存不足时才会被回收，而被弱引用 关联的对象在JVM进行垃圾回收时总会被回收。总结起来： 软引用，内存不足才回收；弱引用，发现即回收。
在垃圾回收时，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。
弱引用 可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
import java.lang.ref.WeakReference;
public class WeakRef {
public static void main(String[] args) {
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
在使用 软引用 和 弱引用 的时候，我们可以显示地通过 System.gc() 来通知 JVM 进行垃圾回收，但是要注意的是，虽然发出了通知，JVM 不一定会立刻执行，也就是说这句是无法确保此时JVM一定会进行垃圾回收的。
这说明只要JVM进行垃圾回收，被弱引用关联的对象必定会被回收掉。
class VeryBig {
public String id;
byte[] b = new byte[2 * 1024];
public VeryBig(String id) {
this.id = id;
}
protected void finalize() {
System.out.println("回收 VeryBig " + id);
}
@Override
public String toString() {
return "VeryBig [id=" + id + "]";
}
}
/**
* 封装WeakReference
*/
class VeryBigWeakReference extends WeakReference<VeryBig> {
public String id;
public VeryBigWeakReference(VeryBig big, ReferenceQueue<VeryBig> rq) {
super(big, rq);
this.id = big.id;
}
protected void finalize() {
System.out.println("回收 VeryBigWeakReference " + id);
}
@Override
public String toString() {
return "VeryBigWeakReference [id=" + id + "]";
}
}
public class ReferenceTest {
private static ReferenceQueue<VeryBig> queue = new ReferenceQueue<VeryBig>();
private static LinkedList<WeakReference<VeryBig>> linkedList = new LinkedList<WeakReference<VeryBig>>();
public static void main(String args[]) {
int size = 3;
for (int i = 0; i < size; i++) {
linkedList.add(new VeryBigWeakReference(new VeryBig("Weak " + i), queue));
}
System.out.println("第一个VeryBig对象：" + linkedList.getFirst().get());
System.gc();
try {
// 下面休息几分钟，让上面的垃圾回收线程运行完成
TimeUnit.SECONDS.sleep(6);
} catch (InterruptedException e) {
e.printStackTrace();
}
checkQueue();
System.out.println("第一个VeryBig对象：" + linkedList.getFirst().get());
}
/**
* 查看ReferenceQueue是否存在对象
*/
public static void checkQueue() {
Reference<? extends VeryBig> ref = null;
while ((ref = queue.poll()) != null) {
if (ref != null) {
System.out.println("In queue: " + ((VeryBigWeakReference) (ref)).id);
}
}
}
}
运行结果：
第一个VeryBig对象：VeryBig [id=Weak 0]
回收 VeryBig Weak 2
回收 VeryBig Weak 1
回收 VeryBig Weak 0
In queue: Weak 1
In queue: Weak 2
In queue: Weak 0
第一个VeryBig对象：null
面试题 ： 你开发中使用过 WeakHashMap吗， 说说它的特点？
https://blog.csdn.net/piaoslowly/article/details/81909686
4）虚引用
“虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。在java中用 java.lang.ref.PhantomReference 类表示。
如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。
虚引用主要用来跟踪对象被垃圾回收的活动。
虚引用与软引用和弱引用的一个区别：虚引用必须和引用队列（ReferenceQueue ）联合使用。当垃圾回收器准备回收一个对象 时，如果发现它还有虚引用，就会在回收对象之前，把这个虚引用 加入到与之关联的 引用队列 中。
程序可以通过判断 引用队列 中是否已经加入了虚引用，来判断被引用的 对象 是否将要被垃圾回收。
如果程序发现某个虚引用 已经被加入到 引用队列，那么就可以对被引用的 对象 被回收之前采取必要的行动。
垃圾回收时，无法通过引用取到对象值，可以通过如下代码实现
// --------- 创建虚引用 ----------------
Object obj = new Object();
ReferenceQueue<Object> queue = new ReferenceQueue<Object>();
PhantomReference<Object> ref = new PhantomReference<Object>(obj,queue);
obj=null; // 只有obj=null，才是虚引用，否则是强引用
// ===================================
System.out.println(ref.get()); //永远返回 null
System.out.println(ref.isEnqueued()); //false 。返回是否从内存中已经删除
System.gc();
TimeUnit.SECONDS.sleep(6);
System.out.println(ref.isEnqueued()); // true
运行结果：
null
false
true
3、总结
