1 Java中的四种引用
在Java中提供了四个级别的引用：强引用，软引用，弱引用和虚引用。在这四个引用类型中，只有强引用FinalReference类是包内可见，其他三种引用类型均为public，可以在应用程序中直接使用。引用类型的类结构如图所示。
1.1 强引用
Java中的强引用指的是，程序中有直接可达的引用。如
Object obj = new Object();
强引用的特点：
- 强引用可以直接访问目标对象。
- 强引用所指向的对象在任何时候都不会被系统回收。JVM宁愿抛出OOM异常，也不会回收强引用所指向的对象。
- 强引用可能导致内存泄漏。
1.2 软引用
软引用是除了强引用外，最强的引用类型。可以通过java.lang.ref.SoftReference使用软引用。
SoftReference<Object> softRef = new SoftReference<Object>(new Object());
软引用的特点：
1.软引用的对象，只有在内存不足的时候（抛出OOM异常前），垃圾收集器会决定回收该软引用所指向的对象。软引用通常用于实现内存敏感的缓存。
2.在垃圾线程对 这个Java对象回收前，SoftReference类所提供的get()方法返回Java对象的强引用。一旦垃圾线程回收该Java对象之后，get()方法将返回null。
1.3 弱引用
弱引用是一种比软引用较弱的引用类型。可以用java.lang.ref.WeakReference实例来保存对一个Java对象的弱引用。
WeakReference<Object> weakRef = new WeakReference<Object>(new Object());
软引用的特点：
1.不管内存是否足够，只要被垃圾收集器发现，该引用的对象就会被回收
1.4 虚引用
虚引用是所有类型中最弱的一个。一个持有虚引用的对象，和没有引用几乎是一样的，可以用java.lang.ref.WeakReference实例来保存对一个Java对象的弱引用。
Object obj = new Object();
ReferenceQueue<Object> refQueue = new ReferenceQueue<>();
PhantomReference<Object> phantom = new PhantomReference<Object>(obj, refQueue);
虚引用的特点：
1.随时可能被垃圾回收器回收。
2.当试图通过虚引用的get()方法取得强引用时，总是返回null。
3.虚引用必须和引用队列一起使用。
当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在垃圾回收后，销毁这个对象，将这个虚引用加入引用队列。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
2 ReferenceQueue
引用队列，当检测到对象的可到达性更改时，垃圾回收器将已注册的引用对象添加到队列中，ReferenceQueue实现了入队（enqueue）和出队（poll），还有remove操作，内部元素head就是泛型的Reference。
//创建一个引用队列
ReferenceQueue queue = new ReferenceQueue();
// 创建弱引用，此时状态为Active，并且Reference.pending为空，当前Reference.queue = 上面创建的queue，并且next=null
WeakReference reference = new WeakReference(new Object(), queue);
System.out.println(reference);
// 当GC执行后，由于是弱引用，所以回收该object对象，并且置于pending上，此时reference的状态为PENDING
System.gc();
/* ReferenceHandler从pending中取下该元素，并且将该元素放入到queue中，此时Reference状态为ENQUEUED，Reference.queue = ReferenceENQUEUED */
/* 当从queue里面取出该元素，则变为INACTIVE，Reference.queue = Reference.NULL */
Reference reference1 = queue.remove();
System.out.println(reference1);
3 源码分析
3.1Reference定义的4种状态
Reference类首先把内存分为4种状态Active，Pending，Enqueued，Inactive。
- Active，一般来说内存一开始被分配的状态都是 Active，
- Pending 大概是指快要被放进队列的对象，也就是马上要回收的对象，
- Enqueued 就是对象的内存已经被回收了，我们已经把这个对象放入到一个队列中，方便以后我们查询某个对象是否被回收，
- Inactive就是最终的状态，不能再变为其它状态。
3.2 Reference成员变量
// 用于保存对象的引用，GC会根据不同Reference来特别对待
private T referent;
// 如果需要通知机制，则保存的对对应的队列
ReferenceQueue<? super T> queue;
/* 这个用于实现一个单向循环链表，用以将保存需要由ReferenceHandler处理的引用 */
Reference next;
static private class Lock { };
// 锁，用于同步pending队列的进队和出队
private static Lock lock = new Lock();
transient private Reference<T> discovered; /* used by VM */
// 此属性保存一个PENDING的队列，配合上述next一起使用
private static Reference pending = null;
- referent表示其引用的对象，即在构造的时候需要被包装在其中的对象。
- queue 是对象即将被回收时所要通知的队列。当对象即将被回收时，整个reference对象，而不仅仅是被回收的对象，会被放到queue 里面，然后外部程序即可通过监控这个 queue 即可拿到相应的数据了。
- next 即当前引用节点所存储的下一个即将被处理的节点。但 next 仅在放到queue中才会有意义，因为只有在enqueue的时候，会将next设置为下一个要处理的Reference对象。为了描述相应的状态值，在放到队列当中后，其queue就不会再引用这个队列了。而是引用一个特殊的 ENQUEUED（内部定义的一个空队列）。因为已经放到队列当中，并且不会再次放到队列当中。
- discovered 表示要处理的对象的下一个对象。即可以理解要处理的对象也是一个链表，通过discovered进行排队，这边只需要不停地拿到pending，然后再通过discovered 不断地拿到下一个对象赋值给pending即可，直到取到了最有一个。它是被JVM 使用的。
- pending 是等待被入队的引用列表。JVM 收集器会添加引用到这个列表，直到Reference-handler线程移除了它们。这个列表使用 discovered 字段来连接它下一个元素（即 pending 的下一个元素就是discovered对象。r = pending; pending = r.discovered）。
3.3 ReferenceQueue成员变量
// 用于标识没有注册Queue
static ReferenceQueue NULL = new Null();
// 用于标识已经处于对应的Queue中
static ReferenceQueue ENQUEUED = new Null();
static private class Lock { };
/* 互斥锁，用于同步ReferenceHandler的enqueue和用户线程操作的remove和poll出队操作 */
private Lock lock = new Lock();
// 队列
private volatile Reference<? extends T> head = null;
// 队列中的元素个数
private long queueLength = 0;
3.4 对象的入队过程
当 Reference 类被加载的时候，会执行静态代码块。在静态代码块里面，会启动 ReferenceHandler 线程,并设置线程的级别为最大级别， Thread.MAX_PRIORITY。
检查 pending 是否为 null，如果pending不为 null，则将 pending 进行 enqueue，否则线程进入 wait 状态。
private static class ReferenceHandler extends Thread {
----- // 核心代码如下
public void run() {
while (true) {
tryHandlePending(true);
}
}
static boolean tryHandlePending(boolean waitForNotify) {
Reference<Object> r;
Cleaner c;
try {
synchronized (lock) {
// 检查 pending 是否为 null，不为 null，制定 pending enqueue
if (pending != null) {
r = pending;
// 'instanceof' might throw OutOfMemoryError sometimes
// so do this before un-linking 'r' from the 'pending' chain...
c = r instanceof Cleaner ? (Cleaner) r : null;
// unlink 'r' from 'pending' chain
pending = r.discovered;
r.discovered = null;
} else { // 为 null。等待
// The waiting on the lock may cause an OutOfMemoryError
// because it may try to allocate exception objects.
if (waitForNotify) {
lock.wait();
}
// retry if waited
return waitForNotify;
}
}
} catch (OutOfMemoryError x) {
// Give other threads CPU time so they hopefully drop some live references
// and GC reclaims some space.
// Also prevent CPU intensive spinning in case 'r instanceof Cleaner' above
// persistently throws OOME for some time...
Thread.yield();
// retry
return true;
} catch (InterruptedException x) {
// retry
return true;
}
// Fast path for cleaners
if (c != null) {
c.clean();
return true;
}
ReferenceQueue<? super Object> q = r.queue;
if (q != ReferenceQueue.NULL) q.enqueue(r);
return true;
}
}
/******************************ReferenceQueue*************************/
boolean enqueue(Reference<? extends T> r) { /* Called only by Reference class */
synchronized (lock) {
// Check that since getting the lock this reference hasn't already been
// enqueued (and even then removed)
ReferenceQueue<?> queue = r.queue;
// queue 为 null 或者 queue 已经被回收了，直接返回
if ((queue == NULL) || (queue == ENQUEUED)) {
return false;
}
assert queue == this;
// 将 Reference 的状态置为 Enqueued，表示已经被回收
r.queue = ENQUEUED;
// 接着，将 Reference 插入到链表
// 判断当前链表是否为 null，不为 null，将 r.next 指向 head，为 null，head 直接指向 r
r.next = (head == null) ? r : head;
// head 指针指向 r
head = r;
queueLength++;
if (r instanceof FinalReference) {
sun.misc.VM.addFinalRefCount(1);
}
lock.notifyAll();
return true;
}
}
注意：
JVM在GC时会把回收了内存的对象的'Reference'通过'discovered'连接成链表。
‘pending’属性相对于'discovered'链表上面的指针，每次把当前的元素放入引用队列，然后指向链表的下一个元素。
'Reference'的'next'属于用于指向一个已经在队列中被回收的对象。
4 Object的finalize()方法原理
4.1 finalize()方法简介
- 如果一个类实现了finalize方法，那么GC在回收这个对象之前，会将finalize方法进行调用。finalize的一般约定是，jvm虚拟机已经确定没有任何引用或者线程访问此对象，就会调用这个finalize方法。在finalize方法中可以进行任何操作，包括该对象再次对其他线程进行调用。这个方法的目的是在gc回收对象之前，再次对之前未关闭的资源进行回收。如IO操作中的连接等。
- java虚拟机并不保证哪个线程会具体调用finalize方法，但是可以保证调用finalize方法的时候不会有任何用户可见的同步锁。如果finalize方法中出现任何异常，则这些异常会被忽略，且finalize方法会终止。
- 在一个对象调用finalize方法之后，在jvm确认这个对象没有任何其他对象能访问之前，也就是说jvm确认这个对象不是垃圾之前。finalize方法不会执行。
- finalize 方法只会被虚拟机执行一次。
- finalize方法中的异常会被忽略，之后finalize方法会终止。
4.2 FinalReference
FinalReference的实现非常简单，这个类不是public的，其作用域在protected，也就是说除了java.lang.ref包中的类能访问之外，不能在任何自定义的代码中调用。这也说明这是一个jvm才能访问的类。
class FinalReference<T> extends Reference<T> {
public FinalReference(T referent, ReferenceQueue<? super T> q) {
super(referent, q);
}
}
4.3 Finalizer
Finalizer是finalReference的子类，对queue和lock进行了重写。Finalizer也是protected作用域，另外通过final修饰。不可被继承。
//final修饰的类不可被继承
final class Finalizer extends FinalReference<Object> {
//重写了queue属性，Finalizer必须使用ReferenceQueue,因此一开始就对queue进行了实例化
private static ReferenceQueue<Object> queue = new ReferenceQueue<>();
private static Finalizer unfinalized = null;
//重载了锁
private static final Object lock = new Object();
//链表指针，Finalizer是个双向链表
private Finalizer
next = null,
prev = null;
}
4.4 FinalizerThread
jvm在注册的时候，实际上就是创建了一个Finalizer的链表。在GC的时候，如果发现对象只被Finalizer引用，则说明这个对象可以被回收了。那么就将其从引用对象链中取出，放入ReferenceQueue中。之后通知Finalizer Thread线程去消费。之后去调用finalize方法。
private static class FinalizerThread extends Thread {
private volatile boolean running;
FinalizerThread(ThreadGroup g) {
super(g, "Finalizer");
}
public void run() {
if (running)
return;
// Finalizer thread starts before System.initializeSystemClass
// is called. Wait until JavaLangAccess is available
while (!VM.isBooted()) {
// delay until VM completes initialization
try {
VM.awaitBooted();
} catch (InterruptedException x) {
// ignore and continue
}
}
final JavaLangAccess jla = SharedSecrets.getJavaLangAccess();
running = true;
for (;;) {
try {
Finalizer f = (Finalizer)queue.remove();
f.runFinalizer(jla);
} catch (InterruptedException x) {
// ignore and continue
}
}
}
}
/*********************************Finalizer****************************/
private void runFinalizer(JavaLangAccess jla) {
synchronized (this) {
if (hasBeenFinalized()) return;
remove();
}
try {
Object finalizee = this.get();
if (finalizee != null && !(finalizee instanceof java.lang.Enum)) {
jla.invokeFinalize(finalizee);
/* Clear stack slot containing this variable, to decrease
the chances of false retention with a conservative GC */
finalizee = null;
}
} catch (Throwable x) { }
super.clear();
}
流程：
- 在创建对象的时候，如果重写了finalize方法，jvm就会同时创建一个Finalizer对象。
- 所有的Finalizer对象构成一个双向链表
- 所有的Finalizer对象都有一个名为queue的ReferenceQueue队列
- GC在执行标记的最后阶段，会把Finalizer的对象加入到Reference的pending-list 链表中。
- ReferenceHandler会将pending-list中的对象取出，放置到这个ReferenceQueue中。对于finalReference而言，这个queue即使初始化的时候创建的static的queue。对于所有的FinalReference全局只有一个ReferenceQueue。
- Finalizer中有一个专门的守护线程 Finalizer Thread,这个线程中有一个死循环，专门从queue中取出对象，并执行Finalizer中引用对象的finalize方法。之后从队列中移除，强引用消除。
- 再次GC 这个Finalizer的对象没有任何引用，因此可能被回收掉。
Java Reference 源码分析 - Jabnih - 博客园
java 源码系列 - 带你读懂 Reference 和 ReferenceQueue_gdutxiaoxu的博客（微信公众号 stormjun94）-CSDN博客
java中的reference(三): FinalReference和Finalizer的源码分析_dhaibo1986的专栏-CSDN博客
