java编程FinalReference与Finalizer原理示例详解

class FinalReference<T> extends Reference<T> {
    public FinalReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
    }
}

final class Finalizer extends FinalReference<Object> {
    //存放Finalizer的引用队列
    private static ReferenceQueue<Object> queue = new ReferenceQueue<>();
    //当前等待待执行Object#finalize方法的Finalizer节点
    private static Finalizer unfinalized = null;
    //锁对象
    private static final Object lock = new Object();
    //Finalizer链 后续节点与前驱节点
    private Finalizer next = null, prev = null;
    //私有构造函数
    private Finalizer(Object finalizee) {
        super(finalizee, queue);
        //头插法将当前对象加入Finalizer链中
        add();
    }
    
    static void reGISter(Object finalizee) {new Finalizer(finalizee);}
    //头插法将当前对象加入Finalizer链中
    private void add() {
        //获取Finalizer类中全局锁对象对应moniter
        synchronized (lock) {
            if (unfinalized != null) {
                this.next = unfinalized;
                unfinalized.prev = this;
            }
            //更新等待待执行Object#finalize方法的节点
            unfinalized = this;
        }
    }
}

private static class FinalizerThread extends Thread {
    private volatile boolean running;
    FinalizerThread(ThreadGroup g) {
        //这个便是一面提到dump线程时会出现的Finalizer线程的名字
        super(g, "Finalizer");
    }
    public void run() {
        // 避免重复调用run方法
        if (running)
            return;
        // Finalizer线程先于System.initializeSystemClass被调用。等待直到JavaLangAccess可以访问
        while (!VM.isBooted()) {
            try {
                VM.awaitBooted();
            } catch (InterruptedException x) {
                // ignore and continue
            }
        }
        final JavaLangAccess jla = SharedSecrets.getJavaLangAccess();
        running = true;
        //守护线程一直运行
        for (;;) {
            try {
                //从ReferenceQueue中取出Finalizer
                Finalizer f = (Finalizer)queue.remove();
                //调用Finalizer引用对象重写的finalize方法，内部实现上会catch Throwable 异常，保证FinalizerThread线程一直能运行
                f.runFinalizer(jla);
            } catch (InterruptedException x) {
                // ignore and continue
            }
        }
    }
}
static {
    ThreadGroup tg = Thread.currentThread().getThreadGroup();
    for (ThreadGroup tgn = tg;
         tgn != null;
         tg = tgn, tgn = tg.getParent());     
    Thread finalizer = new FinalizerThread(tg);
    //线程优先级没有ReferenceHandler守护线程高
    finalizer.setPriority(Thread.MAX_PRIORITY - 2);
    //设置为守护线程
    finalizer.setDaemon(true);
    //启动线程
    finalizer.start();
}

private void runFinalizer(JavaLangAccess jla) {
    synchronized (this) {
        //已从Finalizer链中摘除，则不再执行Finalizer引用的对象的finalize方法
        if (hasBeenFinalized()) return;
        remove();
    }
    try {
        //获取Finalizer引用的对象
        Object finalizee = this.get();
        if (finalizee != null && !(finalizee instanceof java.lang.Enum)) {
             
            jla.invokeFinalize(finalizee);
            //清除栈中包含的该变量引用，以降低conservative GC 错误的保留该对象的机会
            finalizee = null;
        }
    } catch (Throwable x) { }
    super.clear();
}