引用以及Reference类

public class FinalizeEscapeGC{
  public static FinalizeEscapeGC SAVE_HOOK = null;
  
  public void isAlive(){
    System.out.println("yes, i am still alive");
  }
  
  @Override
  protected void finalize() throws Throwable{
    super.finalize();
    System.out.println("finalize method executed! ");
    FinalizeEscapeGC.SAVE_HOOK = this;
  }
  
  public static void main(String[] args) throws Throwable{
        SAVE_HOOK = new FinalizeEscapeGC();
        //<1> 对象第一次拯救自己  成功
        SAVE_HOOK = null;
        System.gc();
        Thread.sleep(500);
        if (SAVE_HOOK != null)
            SAVE_HOOK.isAlive();
        else {
            System.out.println("no, i am dea :(");
        }

        //<2> 对象第二次拯救自己 失败
        SAVE_HOOK = null;
        System.gc();
        Thread.sleep(500);
        if (SAVE_HOOK != null)
            SAVE_HOOK.isAlive();
        else {
            System.out.println("no, i am dea :(");
        }
  }
}

finalize method executed! 
yes, i am still alive
no, i am dea :(

static {
    //省略部分代码...
    Thread handler = new ReferenceHandler(tg, "Reference Handler");
    handler.setPriority(Thread.MAX_PRIORITY);
    handler.setDaemon(true);
    handler.start();
    //省略部分代码...
}

public void run() {
    //死循环，线程启动后会一直运行
    while (true) {
        tryHandlePending(true);
    }
}


static boolean tryHandlePending(boolean waitForNotify) {
    Reference<Object> r;
    Cleaner c;
    try {
        //上锁
        synchronized (lock) {
            //<1> 如果JVM 发现有满足回收的对象，则会加入Reference 中的 pending链表。
            //    这里会进行判断，如果有则取出来 并在pending链表上断开
            if (pending != null) {
                r = pending;
                //instanceof 可能会抛出OOME，所以在将r从pending链上断开前，做这个处理
                c = r instanceof Cleaner ? (Cleaner) r : null;
                //将将r从pending链上断开
                pending = r.discovered;
                r.discovered = null;
            //<2> 目前还没有，则wait等待
            } else {
                //等待CG后的通知
                if (waitForNotify) {
                    lock.wait();
                }
                //重试
                return waitForNotify;
            }
        }
    } catch (OutOfMemoryError x) {
        //当抛出OOME时，放弃CPU的运行时间，这样有希望收回一些存活的引用并且GC能回收部分空间。同时能避免频繁地自旋重试，导致连续的OOME异常
        Thread.yield();
        //重试
        return true;
    } catch (InterruptedException x) {
         //重试
        return true;
    }
    //<3> 在上面的pending链表中取出来的结果，如果是Cleaner类型的Reference调用其clean方法并退出
    if (c != null) {
        c.clean();
        return true;
    }
    ReferenceQueue<? super Object> q = r.queue;
    //<4> 如果Reference有注册ReferenceQueue，则处理pending指向的Reference结点将其加入ReferenceQueue中
    if (q != ReferenceQueue.NULL) q.enqueue(r);
    return true;
}

//构造函数，指定引用的对象referent
Reference(T referent) {
    this(referent, null);
}
//构造函数，指定引用的对象referent与注册的queue
Reference(T referent, ReferenceQueue<? super T> queue) {
    this.referent = referent;
    this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
}

//Reference

//将当前对象加入创建时注册的queue中
public boolean enqueue() {
    return this.queue.enqueue(this);
}

//ReferenceQueue

//入列队enqueue方法，只被Reference类调用，也就是上面分析中ReferenceHandler线程为调用
boolean enqueue(Reference<? extends T> r) {
	//获取同步对象lock对应的监视器对象
    synchronized (lock) {
        //获取r关联的ReferenceQueue，如果创建r时未注册ReferenceQueue则为NULL，同样如果r已从ReferenceQueue中移除其也为null
        ReferenceQueue<?> queue = r.queue;
        //判断queue是否为NULL 或者 r已加入ReferenceQueue中，是的话则入队列失败
        if ((queue == NULL) || (queue == ENQUEUED)) {
            return false;
        }
        assert queue == this;
        //设置r的queue为已入队列
        r.queue = ENQUEUED;
        //如果ReferenceQueue头节点为null则r的next节点指向当前节点，否则指向头节点
        r.next = (head == null) ? r : head;
        //更新ReferenceQueue头节点
        head = r;
        //列队长度加1
        queueLength++;
        //为FinalReference类型引用增加FinalRefCount数量
        if (r instanceof FinalReference) {
            sun.misc.VM.addFinalRefCount(1);
        }
        //通知remove操作队列有节点
        lock.notifyAll();
        return true;
    }
}

public Reference<? extends T> poll() {
    //头结点为null直接返回，代表Reference还没有加入ReferenceQueue中
    if (head == null)
        return null;
    //获取同步对象lock对应的监视器对象
    synchronized (lock) {
        return reallyPoll();
    }
}
//从队列中真正poll元素的方法
private Reference<? extends T> reallyPoll() {
    Reference<? extends T> r = head;
    //double check 头节点不为null
    if (r != null) {
    	//保存头节点的下个节点引用
        Reference<? extends T> rn = r.next;
        //更新queue头节点引用
        head = (rn == r) ? null : rn;
        //更新Reference的queue值，代表r已从队列中移除
		r.queue = NULL;
		//更新Reference的next为其本身
        r.next = r;
        queueLength--;
        //为FinalReference节点FinalRefCount数量减1
        if (r instanceof FinalReference) {
            sun.misc.VM.addFinalRefCount(-1);
        }
        //返回获取的节点
        return r;
    }
    return null;
}


public Reference<? extends T> remove(long timeout) throws IllegalArgumentException, InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("Negative timeout value");
    }
    //获取同步对象lock对应的监视器对象
    synchronized (lock) {
    	//获取队列头节点指向的Reference
        Reference<? extends T> r = reallyPoll();
        //获取到返回
        if (r != null) return r;
        long start = (timeout == 0) ? 0 : System.nanoTime();
        //在timeout时间内尝试重试获取
        for (;;) {
        	//等待队列上有结点通知
            lock.wait(timeout);
            //获取队列中的头节点指向的Reference
            r = reallyPoll();
            //获取到返回
            if (r != null) return r;
            if (timeout != 0) {
                long end = System.nanoTime();
                timeout -= (end - start) / 1000_000;
                //已超时但还没有获取到队列中的头节点指向的Reference返回null
                if (timeout <= 0) return null;
                start = end;
            }
        }
    }
}

//继承了PhantomReference类也就是虚引用，PhantomReference源码很简单只是重写了get方法返回null
public class Cleaner extends PhantomReference<Object> {
	/* 虚队列，命名很到位。之前说CG把ReferenceQueue加入pending-Reference链中后，ReferenceHandler线程在处理时
     * 是不会将对应的Reference加入列队的，而是调用Cleaner.clean方法。但如果Reference不注册ReferenceQueue，GC处理时
     * 又无法把他加入到pending-Reference链中，所以Cleaner里面有了一个dummyQueue成员变量。
     */
    private static final ReferenceQueue<Object> dummyQueue = new ReferenceQueue();
    //Cleaner链表的头结点
    private static Cleaner first = null;
    //当前Cleaner节点的后续节点
    private Cleaner next = null;
    //当前Cleaner节点的前续节点
    private Cleaner prev = null;
    //真正执行清理工作的Runnable对象，实际clean内部调用thunk.run()方法
    private final Runnable thunk;
    //省略部分代码...
}

//私有方法，不能直接new
private Cleaner(Object var1, Runnable var2) {
    super(var1, dummyQueue);
    this.thunk = var2;
}
//创建Cleaner对象，同时加入Cleaner链中。
public static Cleaner create(Object var0, Runnable var1) {
    return var1 == null ? null : add(new Cleaner(var0, var1));
}
//头插法将新创意的Cleaner对象加入双向链表，synchronized保证同步
private static synchronized Cleaner add(Cleaner var0) {
    if (first != null) {
        var0.next = first;
        first.prev = var0;
    }
    //更新头节点引用
    first = var0;
    return var0;
}

public void clean() {
	//从Cleaner链表中先移除当前节点
    if (remove(this)) {
        try {
        	//调用thunk.run()方法执行对应清理逻辑
            this.thunk.run();
        } catch (final Throwable var2) {
           //省略部分代码..
        }

    }
}

public static ByteBuffer allocateDirect(int capacity) {
    return new DirectByteBuffer(capacity);
}

DirectByteBuffer(int cap) {
    //省略部分代码...
    try {
    	//调用unsafe分配内存
        base = unsafe.allocateMemory(size);
    } catch (OutOfMemoryError x) {
       //省略部分代码...
    }
    //省略部分代码...
    //<1> 前面分析中的Cleaner对象创建，持有当前DirectByteBuffer的引用
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
    att = null;
}

public void run() {
    if (address == 0) {
        // Paranoia
        return;
    }
    //通过unsafe.freeMemory释放创建的堆外内存
    unsafe.freeMemory(address);
    address = 0;
    Bits.unreserveMemory(size, capacity);
}

//Entry继承了WeakReference, WeakReference引用的是Map的key
private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
    V value;
    final int hash;
    Entry<K,V> next;
    /**
     * 创建Entry对象，上面分析过的ReferenceQueue，这个queue实际是WeakHashMap的成员变量，
     * 创建WeakHashMap时其便被初始化 final ReferenceQueue<Object> queue = new ReferenceQueue<>()
     */
    Entry(Object key, V value,
          ReferenceQueue<Object> queue,
          int hash, Entry<K,V> next) {
        super(key, queue);
        this.value = value;
        this.hash  = hash;
        this.next  = next;
    }
    //省略部分原码...
}

private void expungeStaleEntries() {
    //不断地从ReferenceQueue中取出，那些只有被WeakReference对象引用的对象的Reference
    for (Object x; (x = queue.poll()) != null; ) {
        synchronized (queue) {
            //转为 entry
            Entry<K,V> e = (Entry<K,V>) x;
            //计算其对应的桶的下标
            int i = indexFor(e.hash, table.length);
            //取出桶中元素
            Entry<K,V> prev = table[i];
            Entry<K,V> p = prev;
            //桶中对应位置有元素，遍历桶链表所有元素
            while (p != null) {
                Entry<K,V> next = p.next;
                //如果当前元素(也就是entry)与queue取出的一致，将entry从链表中去除
                if (p == e) {
                    if (prev == e)
                        table[i] = next;
                    else
                        prev.next = next;
                    // Must not null out e.next;
                    //清空entry对应的value
                    e.value = null;
                    size--;
                    break;
                }
                prev = p;
                p = next;
            }
        }
    }
}

//share/vm/oops/instanceKlass.cpp
instanceOop InstanceKlass::allocate_instance(TRAPS) {
  bool has_finalizer_flag = has_finalizer(); // Query before possible GC
  int size = size_helper();  // Query before forming handle.

  KlassHandle h_k(THREAD, this);

  instanceOop i;

  i = (instanceOop)CollectedHeap::obj_allocate(h_k, size, CHECK_NULL);
  //<1> 如果该类复写 Object.finalizer() 方法 则把_has_finalizer_flag置为true
  if (has_finalizer_flag && !RegisterFinalizersAtInit) {
    i = register_finalizer(i, CHECK_NULL);
  }
  return i;
}

//然后会调用register_finalizer
instanceOop InstanceKlass::register_finalizer(instanceOop i, TRAPS) {
  if (TraceFinalizerRegistration) {
    tty->print("Registered ");
    i->print_value_on(tty);
    tty->print_cr(" (" INTPTR_FORMAT ") as finalizable", (address)i);
  }
  instanceHandle h_i(THREAD, i);
  // Pass the handle as argument, JavaCalls::call expects oop as jobjects
  JavaValue result(T_VOID);
  JavaCallArguments args(h_i);
  //<2> 这里就是调用Java里面Finalizer 类中的 register 方法
  methodHandle mh (THREAD, Universe::finalizer_register_method());
  JavaCalls::call(&result, mh, &args, CHECK_NULL);
  return h_i();
}

/* Invoked by VM */
static void register(Object finalizee) {
        //<1> 创建实例
        new Finalizer(finalizee);
    }

private Finalizer(Object finalizee) {
        //<2> 放入父类中的ReferenceQueue中(Reference类)
        super(finalizee, queue);
        //<3> 所有的复写finalizer 方法的类组成一个双向链表 叫unfinalized
        add();
    }

private void add() {
        synchronized (lock) {
            if (unfinalized != null) {
                this.next = unfinalized;
                unfinalized.prev = this;
            }
            unfinalized = this;
        }
    }

static {
        ThreadGroup tg = Thread.currentThread().getThreadGroup();
        for (ThreadGroup tgn = tg;
             tgn != null;
             tg = tgn, tgn = tg.getParent());
        //创建FinalizerThread 线程
        Thread finalizer = new FinalizerThread(tg);
        finalizer.setPriority(Thread.MAX_PRIORITY - 2);
        finalizer.setDaemon(true);
        finalizer.start();
    }


private static class FinalizerThread extends Thread {
        private volatile boolean running;
        FinalizerThread(ThreadGroup g) {
            super(g, "Finalizer");
        }
        public void run() {
            // in case of recursive call to 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;
            //死循环调用 runFinalizer方法
            for (;;) {
                try {
                    Finalizer f = (Finalizer)queue.remove();
                    f.runFinalizer(jla);
                } catch (InterruptedException x) {
                    // ignore and continue
                }
            }
        }
    }

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();
    }