以 ZGC 为例，谈一谈 JVM 是如何实现 Reference 语义的

Object gcRoot = new Object();

SoftReference gcRoot = new SoftReference<Object>(new Object());

Cache<Object, Object> softCache = CacheBuilder.newBuilder().softValues().build();

public class PooledKryoFactory extends AbstractKryoFactory {
    private KryoPool pool;
    public PooledKryoFactory() {        pool = new KryoPool.Builder(this).softReferences().build();    }
    @Override    public Kryo getKryo() {        return pool.borrow();    }
    @Override    public void returnKryo(Kryo kryo) {        pool.release(kryo);    }}

public class ThreadLocalKryoFactory extends AbstractKryoFactory {
    private final ThreadLocal<Kryo> holder = new ThreadLocal<Kryo>() {        @Override        protected Kryo initialValue() {            return create();        }    };
    @Override    public void returnKryo(Kryo kryo) {        // do nothing    }
    @Override    public Kryo getKryo() {        return holder.get();    }}

WeakReference gcRoot = new WeakReference<Object>(new Object());

Cache<Object,Object> weakCache = CacheBuilder.newBuilder().weakKeys().weakValues().build();

private static final class Stack<T> {        final WeakReference<Thread> threadRef;}

private static final class WeakOrderQueue extends WeakReference<Thread> {}

private static final class DefaultResourceLeak<T> extends WeakReference<Object> implements ResourceLeakTracker<T>, ResourceLeak {
    private final Set<DefaultResourceLeak<?>> allLeaks;
    DefaultResourceLeak(                Object referent,                ReferenceQueue<Object> refQueue,                Set<DefaultResourceLeak<?>> allLeaks) {            // 弱引用 ByteBuf            super(referent, refQueue);                // 将弱引用 DefaultResourceLeak 放入全局 allLeaks 集合中            allLeaks.add(this);            this.allLeaks = allLeaks;    }}

public abstract class AbstractReferenceCountedByteBuf extends AbstractByteBuf {   // 引用计数   private volatile int refCnt = updater.initialValue();}

   ThreadLocal<Object> gcRoot = new ThreadLocal<Object>(){            @Override            protected Object initialValue() {                return new Object();            }   };

public class Thread implements Runnable {        ThreadLocal.ThreadLocalMap threadLocals = null;}

static class ThreadLocalMap {        private Entry[] table;}

static class Entry extends WeakReference<ThreadLocal<?>> {         Object value;        Entry(ThreadLocal<?> k, Object v) {                       // 弱引用                     super(k);                // 强引用                value = v;        }}

        ThreadLocal<Object> gcRoot = new ThreadLocal<Object>(){            @Override            protected Object initialValue() {                return new Object();            }        };
        gcRoot.get();

public class ThreadLocal<T> {    public T get() {        Thread t = Thread.currentThread();        // 获取本地线程中存储的 ThreadLocal 变量副本        ThreadLocalMap map = getMap(t);        if (map != null) {            // 以 ThreadLocal 对象为 key，到哈希表 table 中查找对应的 Entry 结构            ThreadLocalMap.Entry e = map.getEntry(this);            if (e != null) {                // 返回该 threadLocal 对象对应的 value。                T result = (T)e.value;                return result;            }        }        // 如果 threadLocal 对象还未设置 value 值的话，则调用 initialValue 初始化 threadLocal 对象的值        return setInitialValue();    }}

       private int expungeStaleEntry(int staleSlot) {            Entry[] tab = table;            int len = tab.length;
            // 将当前遍历到的 Entry 以及与其关联的 value 设置为 null             tab[staleSlot].value = null;            tab[staleSlot] = null;            size--;                Entry e;            int i;            // 遍历整个 ThreadLocalMap，清理无用的 Entry            for (i = nextIndex(staleSlot, len);                 (e = tab[i]) != null;                 i = nextIndex(i, len)) {                ThreadLocal<?> k = e.get();                if (k == null) {                    e.value = null;                    tab[i] = null;                    size--;                }             }            return i;        }

        // 参数 i 表示开发定址定位到的 Entry 位置        // n 为当前 ThreadLocalMap 的 size        private boolean cleanSomeSlots(int i, int n) {            boolean removed = false;            Entry[] tab = table;            int len = tab.length;            do {                i = nextIndex(i, len);                Entry e = tab[i];                // 如果发现有一个是无用 Entry                if (e != null && e.refersTo(null)) {                    // 遍历整个 ThreadLocalMap 清理所有无用的 Entry 对象                    i = expungeStaleEntry(i);                }            } while ( (n >>>= 1) != 0); // 向后扫描 log2(size) 个 Entry            return removed;        }

        private void remove(ThreadLocal<?> key) {            Entry[] tab = table;            int len = tab.length;            // 确定 key 在 table 中的起始位置            int i = key.threadLocalHashCode & (len-1);            for (Entry e = tab[i];                 e != null;                 e = tab[i = nextIndex(i, len)]) {                if (e.refersTo(key)) {                    // 断开 Entry  到 ThreadLocal 对象之间的弱引用关系                    e.clear();                    // 清理 key 为 null 的 Entry 对象。                    expungeStaleEntry(i);                    return;                }            }        }

public class PhantomReference<T> extends Reference<T> {    public T get() {        return null;    }}

public abstract class Reference<T> {}
public class SoftReference<T> extends Reference<T> {}public class WeakReference<T> extends Reference<T> {}public class PhantomReference<T> extends Reference<T> {}

class DirectByteBuffer extends MappedByteBuffer implements DirectBuffer{    private final Cleaner cleaner;
    DirectByteBuffer(int cap) {                   // package-private
        ...... 省略 .....           // 检查堆外内存整体用量是否超过了 -XX:MaxDirectMemorySize        // 如果超过则尝试等待一下 JVM 回收堆外内存，回收之后还不够的话则抛出 OutOfMemoryError        Bits.reserveMemory(size, cap);           // 底层调用 malloc 申请虚拟内存        base = UNSAFE.allocateMemory(size);
        ...... 省略 .....   
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));    }}

public class Cleaner extends PhantomReference<Object>{              public static Cleaner create(Object ob, Runnable thunk) {              if (thunk == null)                  return null;              return add(new Cleaner(ob, thunk));        }           // Deallocator        private final Runnable thunk;        // 忽略这个 dummyQueue，Cleaner 并不会用到它        private static final ReferenceQueue<Object> dummyQueue = new ReferenceQueue<>();
        private Cleaner(Object referent, Runnable thunk) {            // 调用 PhantomReference 类的构造函数            super(referent, dummyQueue);            // Deallocator            this.thunk = thunk;        }}

public abstract class Reference<T> {    // PhantomReference 虚引用的对象    private T referent;    // 暂时先不要管这个 ReferenceQueue，但它是非常重要的一个概念    volatile ReferenceQueue<? super T> queue;
    Reference(T referent, ReferenceQueue<? super T> queue) {        //  PhantomReference 虚引用了 DirectByteBuffer 对象        this.referent = referent;        this.queue = (queue == null) ? ReferenceQueue.NULL : queue;    }}

public class Cleaner extends PhantomReference<Object>{    private static Cleaner first = null;
    private Cleaner next = null, prev = null;}

    private static synchronized Cleaner add(Cleaner cl) {        if (first != null) {            cl.next = first;            first.prev = cl;        }        first = cl;        return cl;    }

    // 具体资源的释放逻辑封装在 thunk 中    // Deallocator 对象    private final Runnable thunk;
    public void clean() {        // 将该 Cleaner 对象从双向链表中删除，目的是断开 Cleaner 对象的强引用链        // 等到下一次 GC 的时候就可以回收这个 Cleaner 对象了        if (!remove(this))            return;        try {            // 进行资源清理            thunk.run();        } catch (final Throwable x) {           .... 省略 ....        }    }

   private static class Deallocator implements Runnable   {        // native memory 的起始内存地址        private long address;        // OS 实际申请的 native memory 大小        private long size;        // DirectByteBuffer 的容量        private int capacity;
        public void run() {            if (address == 0) {                // Paranoia                return;            }            // 底层调用 free 来释放 native memory            UNSAFE.freeMemory(address);            address = 0;            // 更新 direct memory 的用量统计信息            Bits.unreserveMemory(size, capacity);        }    }

class DirectByteBuffer extends MappedByteBuffer implements DirectBuffer{    private final Cleaner cleaner;
    DirectByteBuffer(int cap) {                   // package-private
        ...... 省略 .....   
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));    }}

public class FileChannelImpl extends FileChannel{   public MappedByteBuffer map(MapMode mode, long position, long size) throws IOException {          Unmapper unmapper = mapInternal(mode, position, size, prot, isSync);           return Util.newMappedByteBuffer((int)unmapper.cap,                    unmapper.address + unmapper.pagePosition,                    unmapper.fd,                    unmapper, isSync);        }}

class DirectByteBuffer extends MappedByteBuffer implements DirectBuffer{   protected DirectByteBuffer(int cap, long addr,                                     FileDescriptor fd,                                     Runnable unmapper,                                     boolean isSync, MemorySegmentProxy segment)    {        super(-1, 0, cap, cap, fd, isSync, segment);        address = addr;        cleaner = Cleaner.create(this, unmapper);        att = null;    }}

 private static abstract class Unmapper implements Runnable, UnmapperProxy {
    @Override    public void run() {            unmap();    }
    public void unmap() {            if (address == 0)                return;            // 底层调用 unmmap 系统调用，释放由 mmap 映射出来的虚拟内存以及物理内存            unmap0(address, size);            address = 0;
            // if this mapping has a valid file descriptor then we close it            if (fd.valid()) {                try {                    nd.close(fd);                } catch (IOException ignore) {                    // nothing we can do                }            }        }  }

public abstract class Reference<T> {
    static {        ThreadGroup tg = Thread.currentThread().getThreadGroup();        // 获取 system thread group        for (ThreadGroup tgn = tg;             tgn != null;             tg = tgn, tgn = tg.getParent());        // 创建 system thread : ReferenceHandler        Thread handler = new ReferenceHandler(tg, "Reference Handler");        // 设置 ReferenceHandler 线程的优先级为最高优先级        handler.setPriority(Thread.MAX_PRIORITY);        handler.setDaemon(true);        handler.start();      }}

// zReferenceProcessor.cpp 文件OopHandle Universe::_reference_pending_list;
// Create a handle for reference_pending_list _reference_pending_list = OopHandle(vm_global(), NULL);

public abstract class Reference<T> {     private transient Reference<?> discovered;}

public abstract class Reference<T> {     private T referent; }

 public T get() {        return this.referent; }

    private static class ReferenceHandler extends Thread {        public void run() {            while (true) {                processPendingReferences();            }        }    }

public abstract class Reference<T> {  /*     * Atomically get and clear (set to null) the VM's pending-Reference list.     */    private static native Reference<?> getAndClearReferencePendingList();
    /*     * Test whether the VM's pending-Reference list contains any entries.     */    private static native boolean hasReferencePendingList();
    /*     * Wait until the VM's pending-Reference list may be non-null.     */    private static native void waitForReferencePendingList();}

// Reference.c 文件JNIEXPORT void JNICALLJava_java_lang_ref_Reference_waitForReferencePendingList(JNIEnv *env, jclass ignore){    JVM_WaitForReferencePendingList(env);}
// jvm.cpp 文件JVM_ENTRY(void, JVM_WaitForReferencePendingList(JNIEnv* env))  MonitorLocker ml(Heap_lock);  while (!Universe::has_reference_pending_list()) {    // 如果 _reference_pending_list 还没有 Reference 对象，那么当前线程在 Heap_lock 上 wait    ml.wait();  }JVM_END
// universe.cpp 文件bool Universe::has_reference_pending_list() {  assert_pll_ownership();  // 检查 _reference_pending_list 是否为空  return _reference_pending_list.peek() != NULL;}

// Reference.c 文件JNIEXPORT jobject JNICALLJava_java_lang_ref_Reference_getAndClearReferencePendingList(JNIEnv *env, jclass ignore){    return JVM_GetAndClearReferencePendingList(env);}
// jvm.cpp 文件JVM_ENTRY(jobject, JVM_GetAndClearReferencePendingList(JNIEnv* env))  MonitorLocker ml(Heap_lock);  // 从 JVM 中获取 _reference_pending_list  oop ref = Universe::reference_pending_list();  if (ref != NULL) {    // 将 JVM 中的 _reference_pending_list 置为 null    // 方便下一轮 GC 处理其他 reference 对象     Universe::clear_reference_pending_list();  }  // 将 _reference_pending_list 返回给 ReferenceHandler 线程  return JNIHandles::make_local(THREAD, ref);JVM_END
// universe.cpp 文件oop Universe::reference_pending_list() {  if (Thread::current()->is_VM_thread()) {    assert_pll_locked(is_locked);  } else {    assert_pll_ownership();  }  // 返回 _reference_pending_list  return _reference_pending_list.resolve();}
void Universe::clear_reference_pending_list() {  assert_pll_ownership();  // 将 _reference_pending_list 设置为 null  _reference_pending_list.replace(NULL);}

    private static final Object processPendingLock = new Object();    private static boolean processPendingActive = false;
    private static void processPendingReferences() {        // ReferenceHandler 线程等待 JVM 向 _reference_pending_list 填充 Reference 对象        // GC 之后，如果有 Reference 对象需要处理，JVM 则将 ReferenceHandler 线程 唤醒        waitForReferencePendingList();        // 用于指向 JVM 的 _reference_pending_list        Reference<?> pendingList;        synchronized (processPendingLock) {            // 获取 _reference_pending_list，随后将 _reference_pending_list 置为 null            // 方便 JVM 在下一轮 GC 处理其他 Reference 对象            pendingList = getAndClearReferencePendingList();            // true 表示 ReferenceHandler 线程正在处理 pendingList            processPendingActive = true;        }        // 将 pendingList 中的 Reference 对象挨个从链表中摘下处理        while (pendingList != null) {            // 从 pendingList 中摘下 Reference 对象            Reference<?> ref = pendingList;            pendingList = ref.discovered;            ref.discovered = null;                        // 如果该 Reference 对象是 Cleaner 类型，那么在这里就会调用它的 clean 方法            if (ref instanceof Cleaner) {                 // Cleaner 的 clean 方法就是在这里调用的                ((Cleaner)ref).clean();                          synchronized (processPendingLock) {                    // 将等待在 processPendingLock 上的其他 Java 业务线程唤醒                    processPendingLock.notifyAll();                }            } else {                // 这里处理除 Cleaner 之外的其他 Reference 对象                // 比如，其他 PhantomReference，WeakReference，SoftReference，FinalReference                // 将他们添加到对应的 ReferenceQueue 中                ref.enqueueFromPending();            }        }        // 本次 GC 收集到的 Reference 对象到这里就全部处理完了        synchronized (processPendingLock) {            // false 表示 ReferenceHandler 线程已经处理完毕 pendingList            processPendingActive = false;            // 唤醒其他等待在 processPendingLock 上 Java 线程。            processPendingLock.notifyAll();        }    }

    public void clean() {        if (!remove(this))            return;        try {            // 进行资源清理            thunk.run();        } catch (final Throwable x) {           .... 省略 ....        }    }

   private static class Deallocator implements Runnable   {        public void run() {                // 底层调用 free 来释放 native memory            UNSAFE.freeMemory(address);        }    }

public class Cleaner extends PhantomReference<Object>{    private static Cleaner first = null;
    private Cleaner next = null, prev = null;}

public abstract class Reference<T> {
   volatile ReferenceQueue<? super T> queue;
   private void enqueueFromPending() {        var q = queue;        if (q != ReferenceQueue.NULL) q.enqueue(this);    }}

public abstract class Reference<T> {    volatile Reference next;}

    Reference(T referent, ReferenceQueue<? super T> queue) {        // 被引用的普通 Java 对象        this.referent = referent;        // 全局 ReferenceQueue 实例        this.queue = (queue == null) ? ReferenceQueue.NULL : queue;    }

public Reference<? extends T> poll() 

 public Reference<? extends T> remove(long timeout)        throws IllegalArgumentException, InterruptedException

 public static void main(String[] args) throws Exception{
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
        Object phantomObject = new Object();        Reference phantomReference = new  PhantomReference(phantomObject,referenceQueue);
        Object weakObject = new Object();        Reference weakReference = new WeakReference(weakObject, referenceQueue);
        Object softObject = new Object();        Reference softReference = new SoftReference(softObject, referenceQueue);
        phantomObject = null;        weakObject = null;        // 当内存不足的时候，softObject 才会被回收        softObject = null;                System.gc();
        Reference getReferenceByPoll = referenceQueue.poll();
        long timeout = 1000;        Reference getReferenceByRemove = referenceQueue.remove(timeout);    }

public class WeakHashMap<K,V> extends AbstractMap<K,V>  implements Map<K,V> {    Entry<K,V>[] table;    private final ReferenceQueue<Object> queue = new ReferenceQueue<>();}

    private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {        V value;        final int hash;        Entry<K,V> next;
        /**         * Creates new entry.         */        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;        }}

    public V put(K key, V value) {        Object k = maskNull(key);        int h = hash(k);        Entry<K,V>[] tab = getTable();        int i = indexFor(h, tab.length);
        ...... 省略 ......
        Entry<K,V> e = tab[i];        // 创建 Entry 的时候会传入 ReferenceQueue        tab[i] = new Entry<>(k, value, queue, h, e);
        return null;    }

    private void expungeStaleEntries() {        for (Object x; (x = queue.poll()) != null; ) {            synchronized (queue) {
             ... 将 ReferenceQueue 中的 Entry 全部从 WeakHashMap 中删除 ...
            }        }    }

class DirectByteBuffer extends MappedByteBuffer implements DirectBuffer{    private final Cleaner cleaner;
    DirectByteBuffer(int cap) {                   // package-private
        ...... 省略 .....           // 检查堆外内存整体用量是否超过了 -XX:MaxDirectMemorySize        // 如果超过则尝试等待一下 JVM 回收堆外内存，回收之后还不够的话则抛出 OutOfMemoryError        Bits.reserveMemory(size, cap);           // 底层调用 malloc 申请虚拟内存        base = UNSAFE.allocateMemory(size);
        ...... 省略 .....   
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));    }}

    // -XX:MaxDirectMemorySize 最大允许使用的 direct memory 容量    private static volatile long MAX_MEMORY = VM.maxDirectMemory();    // 向 OS 实际申请的内存，考虑到内存对齐的情况，实际向 OS 申请的内存会比指定的 cap 要多    private static final AtomicLong RESERVED_MEMORY = new AtomicLong();    // 已经使用的 direct memory 总量     private static final AtomicLong TOTAL_CAPACITY = new AtomicLong();
    private static boolean tryReserveMemory(long size, long cap) {
        long totalCap;        while (cap <= MAX_MEMORY - (totalCap = TOTAL_CAPACITY.get())) {            if (TOTAL_CAPACITY.compareAndSet(totalCap, totalCap + cap)) {                RESERVED_MEMORY.addAndGet(size);                COUNT.incrementAndGet();                return true;            }        }        // 已经超过了最大 direct memory 容量的限制则返回 false        return false;    }

public abstract class Reference<T> {
    private static boolean waitForReferenceProcessing()        throws InterruptedException    {        synchronized (processPendingLock) {            // processPendingActive = true 表示 ReferenceHandler 线程正在处理 PendingList 中的 Cleaner，那么就等待 ReferenceHandler 处理完            // hasReferencePendingList 检查 JVM 中的 _reference_pending_list 是否包含待处理的 Reference 对象            // 如果还有待处理的 Reference，那么也等待一下            if (processPendingActive || hasReferencePendingList()) {                // 等待 ReferenceHandler 线程处理 Cleaner 释放 direct memory                processPendingLock.wait();                return true;            } else {                // 当前系统中没有待处理的 Reference，直接返回 false                return false;            }        }    }}

    static void reserveMemory(long size, long cap) {         // 首先检查一下 direct memory 的使用量是否已经超过了 -XX:MaxDirectMemorySize 的限制        if (tryReserveMemory(size, cap)) {            return;        }
        final JavaLangRefAccess jlra = SharedSecrets.getJavaLangRefAccess();        boolean interrupted = false;        try {                  boolean refprocActive;            do {                try {                    // refprocActive = true 表示 ReferenceHandler 线程又释放了一些 direct memory                    // refprocActive = false 表示当前系统中没有待处理的 Cleaner，系统中已经没有任何可回收的 direct memory 了                    refprocActive = jlra.waitForReferenceProcessing();                } catch (InterruptedException e) {                    // Defer interrupts and keep trying.                    interrupted = true;                    refprocActive = true;                }                // 再次检查 direct memory 的容量是否能够满足本次分配请求                if (tryReserveMemory(size, cap)) {                    return;                }            } while (refprocActive);
            // 此时系统中已经没有任何可回收的 direct memory 了            // 只能触发 gc，尝试让 JVM 再去回收一些没有任何强引用的 directByteBuffer            System.gc();                         // 下面开始睡眠等待 ReferenceHandler 线程调用 Cleaner 释放 direct memory            // 初始睡眠时间, 单位 ms            long sleepTime = 1;            // 睡眠次数，最多睡眠 9 次            int sleeps = 0;            while (true) {                if (tryReserveMemory(size, cap)) {                    return;                }                // MAX_SLEEPS = 9                if (sleeps >= MAX_SLEEPS) {                    break;                }                try {                    // 等待 ReferenceHandler 线程处理 Cleaner 释放 direct memory （返回 true）                    // 当前系统中没有任何可回收的 direct memory，则 Thread.sleep 睡眠 (返回 false)                    if (!jlra.waitForReferenceProcessing()) {                        // 睡眠等待其他线程触发 gc，尝试看看后面几轮 gc 是否能够回收到一点 direct memory                        // 最多睡眠 9 次，每次睡眠时间按照 1, 2, 4, 8, 16, 32, 64, 128, 256 ms 依次递增                        Thread.sleep(sleepTime);                        sleepTime <<= 1;                        sleeps++;                    }                } catch (InterruptedException e) {                    interrupted = true;                }            }
            // 在尝试回收 direct memory 511 ms 后触发 OOM            throw new OutOfMemoryError                ("Cannot reserve "                 + size + " bytes of direct buffer memory (allocated: "                 + RESERVED_MEMORY.get() + ", limit: " + MAX_MEMORY +")");
        } finally {        }    }

public abstract class Reference<T> {  private T referent;}

// Describes where oops are located in instances of this klass.class OopMapBlock { public:  // Byte offset of the first oop mapped by this block.  int offset() const          { return _offset; }  void set_offset(int offset) { _offset = offset; }
  // Number of oops in this block.  uint count() const         { return _count; }  void set_count(uint count) { _count = count; }
 private:  int  _offset;  uint _count;};

InstanceKlass* InstanceKlass::allocate_instance_klass(const ClassFileParser& parser, TRAPS) {  // InstanceKlass 实例的内存布局  const int size = InstanceKlass::size(parser.vtable_size(),                                       parser.itable_size(),                                       nonstatic_oop_map_size(parser.total_oop_map_count()),                                       parser.is_interface());
  const Symbol* const class_name = parser.class_name();  assert(class_name != NULL, "invariant");  ClassLoaderData* loader_data = parser.loader_data();  assert(loader_data != NULL, "invariant");
  InstanceKlass* ik;
  // Allocation  if (REF_NONE == parser.reference_type()) {    if (class_name == vmSymbols::java_lang_Class()) {          ...... 省略 ....     }    else if (is_class_loader(class_name, parser)) {          ...... 省略 ....     } else {      // 对于普通的 Java 类来说，这里创建的是 InstanceKlass 实例      ik = new (loader_data, size, THREAD) InstanceKlass(parser, InstanceKlass::_kind_other);    }  } else {    // 对于 Reference 类来说，这里创建的是 InstanceRefKlass 实例    ik = new (loader_data, size, THREAD) InstanceRefKlass(parser);  }  return ik;}

inline OopMapBlock* InstanceKlass::start_of_nonstatic_oop_maps() const {  return (OopMapBlock*)(start_of_itable() + itable_length());}
inline intptr_t* InstanceKlass::start_of_itable()   const { return (intptr_t*)start_of_vtable() + vtable_length(); }

class oopDesc { private:  volatile markWord _mark;  union _metadata {    Klass*      _klass;    narrowKlass _compressed_klass;  } _metadata;}

Klass* oopDesc::klass() const {  if (UseCompressedClassPointers) {    // 开启压缩指针的情况    return CompressedKlassPointers::decode_not_null(_metadata._compressed_klass);  } else {    return _metadata._klass;  }}

template <typename OopClosureType>void oopDesc::oop_iterate(OopClosureType* cl) {  // 遍历对象的所有非静态成员变量  OopIteratorClosureDispatch::oop_oop_iterate(cl, this, klass());}

template <typename T, class OopClosureType>ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_maps(oop obj, OopClosureType* closure) {  // InstanceKlass 中有多个 OopMapBlock，它们在 InstanceKlass 实例内存中会放在一起  // 获取首个 OopMapBlock 地址  OopMapBlock* map           = start_of_nonstatic_oop_maps();  // 获取 InstanceKlass 中包含的 OopMapBlock 个数，这些都是在类加载的时候决定的  // class 文件中有字段表，在类加载的时候可以根据字段表建立 OopMapBlock  OopMapBlock* const end_map = map + nonstatic_oop_map_count();  // 挨个遍历 InstanceKlass 中所有的 OopMapBlock  for (; map < end_map; ++map) {    // OopMapBlock 中包含的是 java 类中非静态成员变量在对象地址中的偏移    // 通过它直接可以获取到成员变量的指针    oop_oop_iterate_oop_map<T>(map, obj, closure);  }}

template <typename T, class OopClosureType>ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_map(OopMapBlock* map, oop obj, OopClosureType* closure) {  // 通过成员变量在 obj 对象内存中的偏移获取成员变量指针  T* p         = (T*)obj->obj_field_addr<T>(map->offset());  // 获取该 OopMapBlock 所映射的成员变量个数  T* const end = p + map->count();  // 遍历成员变量挨个标记  for (; p < end; ++p) {    // 标记成员变量    Devirtualizer::do_oop(closure, p);  }}

public abstract class ClassLoader {    static native Class<?> defineClass1(ClassLoader loader, String name, byte[] b, int off, int len,                                        ProtectionDomain pd, String source);}

static jclass jvm_define_class_common(const char *name,                                      jobject loader, const jbyte *buf,                                      jsize len, jobject pd, const char *source,                                      TRAPS) {  // 将 class 文件的二进制字节流转换为 ClassFileStream  ClassFileStream st((u1*)buf, len, source, ClassFileStream::verify);  // 进行类的加载，验证，解析，随后为创建 InstanceKlass 实例  Klass* k = SystemDictionary::resolve_from_stream(&st, class_name,                                                   class_loader,                                                   cl_info,                                                   CHECK_NULL);}
InstanceKlass* SystemDictionary::resolve_class_from_stream  if (k == NULL) {    k = KlassFactory::create_from_stream(st, class_name, loader_data, cl_info, CHECK_NULL);  }}

InstanceKlass* KlassFactory::create_from_stream(ClassFileStream* stream,                                                Symbol* name,                                                ClassLoaderData* loader_data,                                                const ClassLoadInfo& cl_info,                                                TRAPS) {  // 这里完成类的加载，验证，解析 以及 nonstatic_oop_maps 的构建  ClassFileParser parser(stream,                         name,                         loader_data,                         &cl_info,                         ClassFileParser::BROADCAST, // publicity level                         CHECK_NULL);  // 分配 InstanceKlass 实例，并将构建好的 nonstatic_oop_maps 填充到 InstanceKlass 实例中  InstanceKlass* result = parser.create_instance_klass(old_stream != stream, *cl_inst_info, CHECK_NULL);  return result;}

ClassFileParser::ClassFileParser(ClassFileStream* stream,                                 Symbol* name,                                 ClassLoaderData* loader_data,                                 const ClassLoadInfo* cl_info,                                 Publicity pub_level,                                 TRAPS) :
  ........ 省略 加载，验证，解析逻辑 ......
  // 这里会构建 nonstatic_oop_maps  post_process_parsed_stream(stream, _cp, CHECK);}

void ClassFileParser::post_process_parsed_stream(  ..... 省略 .....
  // 对 Java 类中的字段信息进行布局  _field_info = new FieldLayoutInfo();  FieldLayoutBuilder lb(class_name(), super_klass(), _cp, _fields,                        _parsed_annotations->is_contended(), _field_info);  // 构建 nonstatic_oop_maps  lb.build_layout();}
void FieldLayoutBuilder::build_layout() {  // 在对类中的字段完成布局之后，会调用一个 epilogue() 函数  compute_regular_layout();}
// nonstatic_oop_maps的构建逻辑就在这里void FieldLayoutBuilder::epilogue() {

void FieldLayoutBuilder::epilogue() {  // 开始构建 nonstatic_oop_maps  int super_oop_map_count = (_super_klass == NULL) ? 0 :_super_klass->nonstatic_oop_map_count();  int max_oop_map_count = super_oop_map_count + _nonstatic_oopmap_count;
  OopMapBlocksBuilder* nonstatic_oop_maps =      new OopMapBlocksBuilder(max_oop_map_count);  // 继承父类的 nonstatic_oop_maps  if (super_oop_map_count > 0) {    nonstatic_oop_maps->initialize_inherited_blocks(_super_klass->start_of_nonstatic_oop_maps(),    _super_klass->nonstatic_oop_map_count());  }
  // 为非静态成员变量构建 nonstatic_oop_maps  if (_root_group->oop_fields() != NULL) {    for (int i = 0; i < _root_group->oop_fields()->length(); i++) {      LayoutRawBlock* b = _root_group->oop_fields()->at(i);      // 构建 OopMapBlock，相邻的字段构建在一个 OopMapBlock 中      // 不相邻的字段分别构建在不同的 OopMapBlock 中      nonstatic_oop_maps->add(b->offset(), 1);    }  }
  // 为 @Contended 标注的非静态成员变量构建 nonstatic_oop_maps  // 在静态成员变量上标注 @Contended 将会被忽略  if (!_contended_groups.is_empty()) {    for (int i = 0; i < _contended_groups.length(); i++) {      FieldGroup* cg = _contended_groups.at(i);      if (cg->oop_count() > 0) {        assert(cg->oop_fields() != NULL && cg->oop_fields()->at(0) != NULL, "oop_count > 0 but no oop fields found");        // 构建 OopMapBlock，属于同一个 contended_groups 的成员变量在内存中要放在一起        nonstatic_oop_maps->add(cg->oop_fields()->at(0)->offset(), cg->oop_count());      }    }  }  // 对相邻的  OopMapBlock 进行排序整理  // 确保在内存中相邻排列的非静态成员变量被构建在一个 OopMapBlock 中  nonstatic_oop_maps->compact();
  int nonstatic_field_end = align_up(_layout->last_block()->offset(), heapOopSize);
  // Pass back information needed for InstanceKlass creation  _info->oop_map_blocks = nonstatic_oop_maps;  _info->_nonstatic_field_size = (nonstatic_field_end - instanceOopDesc::base_offset_in_bytes()) / heapOopSize;  _info->_has_nonstatic_fields = _has_nonstatic_fields;}

InstanceKlass* ClassFileParser::create_instance_klass(bool changed_by_loadhook,                                                      const ClassInstanceInfo& cl_inst_info,                                                      TRAPS) {  if (_klass != NULL) {    return _klass;  }  // 分配 InstanceKlass 实例  InstanceKlass* const ik =    InstanceKlass::allocate_instance_klass(*this, CHECK_NULL);  // 填充 InstanceKlass 实例  fill_instance_klass(ik, changed_by_loadhook, cl_inst_info, CHECK_NULL);
  return ik;}

void ClassFileParser::fill_instance_klass(InstanceKlass* ik,                                          bool changed_by_loadhook,                                          const ClassInstanceInfo& cl_inst_info,                                          TRAPS) {
  ik->set_nonstatic_field_size(_field_info->_nonstatic_field_size);  ik->set_has_nonstatic_fields(_field_info->_has_nonstatic_fields);  assert(_fac != NULL, "invariant");  ik->set_static_oop_field_count(_fac->count[STATIC_OOP]);
  // 将构建好的 nonstatic_oop_maps 填充到 InstanceKlass 实例中  OopMapBlocksBuilder* oop_map_blocks = _field_info->oop_map_blocks;  if (oop_map_blocks->_nonstatic_oop_map_count > 0) {    oop_map_blocks->copy(ik->start_of_nonstatic_oop_maps());  }}

public abstract class Reference<T> {  private T referent;  volatile ReferenceQueue<? super T> queue;  volatile Reference next;  private transient Reference<?> discovered;}

void SystemDictionary::initialize(TRAPS) {  // Resolve basic classes  vmClasses::resolve_all(CHECK);}
void vmClasses::resolve_all(TRAPS) {    InstanceRefKlass::update_nonstatic_oop_maps(vmClasses::Reference_klass());}

void InstanceRefKlass::update_nonstatic_oop_maps(Klass* k) {
  // Reference 类中的 referent 字段和 discovered 字段的索引偏移从 OopMapBlock 中清除掉  // 在后面通过 Reference 遍历标记成员变量的时候不需要遍历标记这两个字段  InstanceKlass* ik = InstanceKlass::cast(k);
  OopMapBlock* map = ik->start_of_nonstatic_oop_maps();
  // Updated map starts at "queue", covers "queue" and "next".  const int new_offset = java_lang_ref_Reference::queue_offset();  const unsigned int new_count = 2; // queue and next
   assert(map->offset() == referent_offset, "just checking");   assert(map->count() == count, "just checking");   map->set_offset(new_offset);   map->set_count(new_count);}

public abstract class Reference<T> {  private T referent;  volatile ReferenceQueue<? super T> queue;  volatile Reference next;  private transient Reference<?> discovered;}

// zReferenceProcessor.cpp 文件OopHandle Universe::_reference_pending_list;
// Create a handle for reference_pending_list _reference_pending_list = OopHandle(vm_global(), NULL);

void ZDriver::gc(const ZDriverRequest& request) {  ZDriverGCScope scope(request);
  // Phase 1: Pause Mark Start  // 初始化 gc 相关的统计信息，清空 object alocator 的缓存页，切换地址视图，设置标记条带个数  pause_mark_start();
  // Phase 2: Concurrent Mark  // 标记 gc root, 标记普通对象，以及 Reference 对象  // 经过主动刷新，被动刷新之后，如果标记栈中还有对象，也不会再进行标记了  // 剩下的对象标记任务放到 pause_mark_end 中 STW 阶段执行  concurrent(mark);
  // Phase 3: Pause Mark End 再标记阶段，标记上一阶段剩下的对象  // zgc 低延迟的精髓，如果 1ms 内结束不了 STW 标记，那么就在发起一轮 concurrent 标记  // 目的是降低应用线程的停顿控制在 1ms 以内  while (!pause_mark_end()) {    // 1ms 内没有标记完应用线程本地标记栈的内容，那么就重新开始一轮并发标记。    // Phase 3.5: Concurrent Mark Continue    concurrent(mark_continue);  }
  // Phase 4: Concurrent Mark Free  // 释放标记栈资源  concurrent(mark_free);
  // Phase 5: Concurrent Process Non-Strong References  // 这里就是本小节讨论的重点  concurrent(process_non_strong_references);
  ....... 省略 .......}

class ZReferenceProcessor : public ReferenceDiscoverer {  ZPerWorker<oop>      _discovered_list;  ZContended<oop>      _pending_list;}

void ZMark::follow_object(oop obj, bool finalizable) {  if (finalizable) {    ZMarkBarrierOopClosure<true /* finalizable */> cl;    obj->oop_iterate(&cl);  } else {    // 最终的标记逻辑是在这个闭包中完成的    ZMarkBarrierOopClosure<false /* finalizable */> cl;    // 遍历标记 obj 的所有非静态成员变量    obj->oop_iterate(&cl);  }}

template <typename OopClosureType>void oopDesc::oop_iterate(OopClosureType* cl) {  OopIteratorClosureDispatch::oop_oop_iterate(cl, this, klass());}

template <typename T, class OopClosureType>void InstanceRefKlass::oop_oop_iterate(oop obj, OopClosureType* closure) {  // 遍历 Reference 对象的非静态成员变量，注意这里 referent 字段和 discovered 字段是不会被遍历到的  InstanceKlass::oop_oop_iterate<T>(obj, closure);  // 判断该 Reference 对象是否需要加入到 _discovered_list 中  oop_oop_iterate_ref_processing<T>(obj, closure);}

template <typename T, class OopClosureType>ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_maps(oop obj, OopClosureType* closure) {  OopMapBlock* map           = start_of_nonstatic_oop_maps();  OopMapBlock* const end_map = map + nonstatic_oop_map_count();
  for (; map < end_map; ++map) {    oop_oop_iterate_oop_map<T>(map, obj, closure);  }}

public abstract class Reference<T> {  private T referent;  volatile ReferenceQueue<? super T> queue;  volatile Reference next;  private transient Reference<?> discovered;}

template <typename T, class OopClosureType, class Contains>void InstanceRefKlass::oop_oop_iterate_ref_processing(oop obj, OopClosureType* closure, Contains& contains) {  switch (closure->reference_iteration_mode()) {    case OopIterateClosure::DO_DISCOVERY:      // 执行这里的 discovery 逻辑，发现需要被处理的 Reference 对象      oop_oop_iterate_discovery<T>(obj, reference_type(), closure, contains);      break;
     ...... 省略 .....  }}

template <typename T, class OopClosureType, class Contains>void InstanceRefKlass::oop_oop_iterate_discovery(oop obj, ReferenceType type, OopClosureType* closure, Contains& contains) {  // Try to discover reference and return if it succeeds.  if (try_discover<T>(obj, type, closure)) {    // 走到这里说明 Reference 对象已经被加入到 _discovered_list 中了    // 加入到 _discovered_list 的条件是：    // 1. referent 没有被标记，说明不活跃    // 2. Reference 对象之前没有被添加到 _discovered_list（第一次添加）    return;  }
}

template <typename T, class OopClosureType>bool InstanceRefKlass::try_discover(oop obj, ReferenceType type, OopClosureType* closure) {
  //  ZReferenceProcessor  ReferenceDiscoverer* rd = closure->ref_discoverer();  if (rd != NULL) {      // 从堆中加载 Reference 对象的 referent    oop referent = load_referent(obj, type);    if (referent != NULL) {      if (!referent->is_gc_marked()) {        // Only try to discover if not yet marked.        // true 表示 reference 被加入到 discover-list 中了        return rd->discover_reference(obj, type);      }    }  }  return false;}

bool ZReferenceProcessor::discover_reference(oop reference, ReferenceType type) {
  // true : 表示 referent 还存活（被强引用或者软引用关联），那么就不能放到 _discovered_list  // false ： 表示 referent 不在存活，那么就需要把 reference 放入 _discovered_list  if (!should_discover(reference, type)) {    // Not discovered    return false;  }  // 将 reference 插入到  _discovered_list 中（头插法）  discover(reference, type);
  // Discovered  return true;}

bool ZReferenceProcessor::should_discover(oop reference, ReferenceType type) const {  // 获取 referent 对象的地址视图  volatile oop* const referent_addr = reference_referent_addr(reference);  // 调整 referent 对象的地址视图为 remapped + mark0 也就是 weakgood 视图  // 表示该 referent 对象目前只能通过弱引用链访问到，而不能通过强引用链访问到  // 注意这里是调整 referent 的视图而不是调整 Reference 的视图  const oop referent = ZBarrier::weak_load_barrier_on_oop_field(referent_addr);
  // 此时 Reference 的状态就是 inactive，那么这里将不会重复将 Reference 添加到 _discovered_list 重复处理  if (is_inactive(reference, referent, type)) {    return false;  }  // referent 还被强引用关联，那么 return false 也就是说不能被加入到 discover list 中  if (is_strongly_live(referent)) {    return false;  }  // referent 还被软引用有效关联，那么 return false 也就是说不能被加入到 discover list 中  if (is_softly_live(reference, type)) {    return false;  }
  return true;}

void ZReferenceProcessor::discover(oop reference, ReferenceType type) {  // Add reference to discovered list  // 确保 reference 不在 _discovered_list 中，不能重复添加  assert(reference_discovered(reference) == NULL, "Already discovered");  oop* const list = _discovered_list.addr();  // 头插法，reference->discovered = *list  reference_set_discovered(reference, *list);  // reference 变为 _discovered_list 的头部  *list = reference;}

void ZHeap::process_non_strong_references() {  // Process Soft/Weak/Final/PhantomReferences  _reference_processor.process_references();  // Enqueue Soft/Weak/Final/PhantomReferences  _reference_processor.enqueue_references();}

    void ZReferenceProcessor::process_references() {        // Process discovered lists        ZReferenceProcessorTask task(this);        _workers->run(&task);    }

void ZReferenceProcessor::work() {  // Process discovered references  oop* const list = _discovered_list.addr();  oop* p = list;
  // 循环遍历 _discovered_list，检查之前收集到的 Reference 对象的 referent 是否存活  while (*p != NULL) {    const oop reference = *p;    const ReferenceType type = reference_type(reference);    // 如果该 reference 已经被应用程序处理过了 -> referent == NULL, 那么就不需要再被处理了，直接丢弃    // 如果 referent 依然存活，那么也要丢弃，不能放入 _discovered_list 中    if (should_drop(reference, type)) {      // 如果 referent 是 alive 的或者在上一轮 GC 中已经被处理过，则将 reference 从 _discovered_list 中删除      *p = drop(reference, type);    } else {      // 如果 referent 不是 alive 的，在并发标记阶段没有被标记，那么就让它继续留在 _discovered_list 中      // 这里会调用 reference 的 clear 方法 -> referent 置为 null      // 返回 reference 在 _discovered_list 中的下一个对象，继续 while 循环      p = keep(reference, type);    }  }
  // 将 _discovered_list 原子地添加到 _pending_list 中  if (*list != NULL) {    *p = Atomic::xchg(_pending_list.addr(), *list);    // 清空 _discovered_list    *list = NULL;  }}

bool ZReferenceProcessor::should_drop(oop reference, ReferenceType type) const {  // 获取 Reference 所引用的 referent  const oop referent = reference_referent(reference);  // 如果 Reference 对象在上一轮 GC 中被处理过或者已经被应用线程自己处理了，那么本轮 GC 直接回收掉  // 不会再将 Reference 对象重复添加到 _discovered_list  if (referent == NULL) {    return true;  }    // 如果 referent 仍然存活，那么也会将 Reference 对象移除，不需要被 ReferenceHandler 线程处理  if (type == REF_PHANTOM) {    // 针对 PhantomReference 对象的特殊处理，后面在专门的小节中讲解，这里先忽略    return ZBarrier::is_alive_barrier_on_phantom_oop(referent);  } else {    // 本小节我们重点关注这个分支，主要就是判断这个 referent 是否被标记为 alive    return ZBarrier::is_alive_barrier_on_weak_oop(referent);  }}

oop* ZReferenceProcessor::keep(oop reference, ReferenceType type) {
  // 入队计数加 1  _enqueued_count.get()[type]++;
  // 将 referent 置为 null ，此后 Reference 就变为了 inactive  make_inactive(reference, type);
  // 从 _discovered_list 中获取下一个 Reference 继续循环  return reference_discovered_addr(reference);}

void ZReferenceProcessor::make_inactive(oop reference, ReferenceType type) const {  if (type == REF_FINAL) {      ..... 省略 FinalReference 的处理 ....  } else {    // 这里调用 Reference 对象的 clear 方法将，referent 置为 null    reference_clear_referent(reference);  }}

WeakReference weakReference = new WeakReference<Object>(new Object());weakReference.get();

    void ZReferenceProcessor::enqueue_references() {
        if (_pending_list.get() == NULL) {            // Nothing to enqueue            return;        }
        {            // Heap_lock protects external pending list            MonitorLocker ml(Heap_lock);
            // 将 _pending_list 添加到 _reference_pending_list 中            *_pending_list_tail = Universe::swap_reference_pending_list(_pending_list.get());
            // 唤醒 ReferenceHandler 线程            ml.notify_all();        }
        // 重置 pending list，为下一轮 GC 做准备        _pending_list.set(NULL);        _pending_list_tail = _pending_list.addr();    }

// Reference.c 文件JNIEXPORT void JNICALLJava_java_lang_ref_Reference_waitForReferencePendingList(JNIEnv *env, jclass ignore){    JVM_WaitForReferencePendingList(env);}
// jvm.cpp 文件JVM_ENTRY(void, JVM_WaitForReferencePendingList(JNIEnv* env))  MonitorLocker ml(Heap_lock);  while (!Universe::has_reference_pending_list()) {    // 如果 _reference_pending_list 还没有 Reference 对象，那么当前线程在 Heap_lock 上 wait    ml.wait();  }JVM_END

private static class ReferenceHandler extends Thread {
  private static void processPendingReferences() {
        waitForReferencePendingList();
        ........ 省略 .....  }}

class ZReferenceProcessor : public ReferenceDiscoverer {  // 关于 SoftReference 的处理策略  ReferencePolicy*     _soft_reference_policy;}

void ZDriver::gc(const ZDriverRequest& request) {  ZDriverGCScope scope(request);  ..... 省略 ......}

class ZDriverGCScope : public StackObj {private:  GCCause::Cause             _gc_cause;public:  ZDriverGCScope(const ZDriverRequest& request) :      _gc_cause(request.cause()), {    // Set up soft reference policy    const bool clear = should_clear_soft_references(request);    ZHeap::heap()->set_soft_reference_policy(clear);  }

static bool should_clear_soft_references(const ZDriverRequest& request) {  // Clear soft references if implied by the GC cause  if (request.cause() == GCCause::_wb_full_gc ||      request.cause() == GCCause::_metadata_GC_clear_soft_refs ||      request.cause() == GCCause::_z_allocation_stall) {    // 无条件清理 SoftReference    return true;  }
  // Don't clear  return false;}

ZPage* ZPageAllocator::alloc_page(uint8_t type, size_t size, ZAllocationFlags flags) {  EventZPageAllocation event;
retry:  ZPageAllocation allocation(type, size, flags);  // 判断是否进行阻塞分配 ZPage  if (!alloc_page_or_stall(&allocation)) {    // 如果非阻塞分配  ZPage 失败，直接 Out of memory    return NULL;  }}

void ZReferenceProcessor::set_soft_reference_policy(bool clear) {  static AlwaysClearPolicy always_clear_policy;  static LRUMaxHeapPolicy lru_max_heap_policy;
  if (clear) {    log_info(gc, ref)("Clearing All SoftReferences");    _soft_reference_policy = &always_clear_policy;  } else {    _soft_reference_policy = &lru_max_heap_policy;  }
  _soft_reference_policy->setup();}

void LRUMaxHeapPolicy::setup() {  size_t max_heap = MaxHeapSize;  // 获取最近一次 gc 之后，JVM 堆的最大剩余空间  max_heap -= Universe::heap()->used_at_last_gc();  // 转换为 MB  max_heap /= M;  //  -XX:SoftRefLRUPolicyMSPerMB 默认为 1000 ，单位毫秒  // 表示每 MB 的剩余内存空间中允许 SoftReference 存活的最大时间  _max_interval = max_heap * SoftRefLRUPolicyMSPerMB;  assert(_max_interval >= 0,"Sanity check");}

public class SoftReference<T> extends Reference<T> {    // 由 JVM 来设置，每次 GC 发生的时候，JVM 都会记录一个时间戳到这个 clock 字段中    private static long clock;    // 表示应用线程最近一次访问这个 SoftReference 的时间戳（当前的 clock 值）    // 在 SoftReference 的 get 方法中设置    private long timestamp;
    public SoftReference(T referent) {        super(referent);        this.timestamp = clock;    }
    public T get() {        T o = super.get();        if (o != null && this.timestamp != clock)            // 将最近一次的 gc 发生时间设置到 timestamp 中            // 用这个表示当前 SoftReference 最近被访问的时间戳            // 注意这里的时间戳语义是 最近一次的 gc 时间            this.timestamp = clock;        return o;    }}

void ZReferenceProcessor::process_references() {  ZStatTimer timer(ZSubPhaseConcurrentReferencesProcess);
  // Process discovered lists  ZReferenceProcessorTask task(this);  // gc _workers 一起运行 ZReferenceProcessorTask  _workers->run(&task);
  // Update SoftReference clock  soft_reference_update_clock();}

static void soft_reference_update_clock() {  const jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;  java_lang_ref_SoftReference::set_clock(now);}

bool ZReferenceProcessor::should_discover(oop reference, ReferenceType type) const {
  // 此时 Reference 的状态就是 inactive，那么这里将不会重复将 Reference 添加到 _discovered_list 重复处理  if (is_inactive(reference, referent, type)) {    return false;  }  // referent 还被强引用关联，那么 return false 也就是说不能被加入到 discover list 中  if (is_strongly_live(referent)) {    return false;  }  // referent 现在只被软引用关联，那么就需要通过 LRUMaxHeapPolicy  // 来判断这个 SoftReference 所引用的 referent 是否应该存活  if (is_softly_live(reference, type)) {    return false;  }
  return true;}

bool ZReferenceProcessor::is_softly_live(oop reference, ReferenceType type) const {  if (type != REF_SOFT) {    // Not a SoftReference    return false;  }
  // Ask SoftReference policy  // 获取 SoftReference 中的 clock 字段，这里存放的是上一次 gc 的时间戳  const jlong clock = java_lang_ref_SoftReference::clock();  // 判断是否应该清除这个 SoftReference  return !_soft_reference_policy->should_clear_reference(reference, clock);}

// The oop passed in is the SoftReference object, and not// the object the SoftReference points to.bool LRUMaxHeapPolicy::should_clear_reference(oop p,                                             jlong timestamp_clock) {  // 相当于 SoftReference.clock - SoftReference.timestamp  jlong interval = timestamp_clock - java_lang_ref_SoftReference::timestamp(p);

  // The interval will be zero if the ref was accessed since the last scavenge/gc.  // 如果 clock 与 timestamp 的差值小于等于 _max_interval （SoftReference 的最大存活时间）  if(interval <= _max_interval) {    // SoftReference 所引用的 referent 对象在本轮 GC 中就不会被回收    return false;  }  // interval 大于 _max_interval，这个 SoftReference 所引用的 referent 对象就会被回收  // SoftReference 也会被放到 _reference_pending_list 中等待 ReferenceHandler 线程去处理  return true;}

public class Object {    @Deprecated(since="9")    protected void finalize() throws Throwable { }}

instanceOop InstanceKlass::allocate_instance(TRAPS) {  // 判断这个类是否重写了 finalize() 方法  bool has_finalizer_flag = has_finalizer();   instanceOop i;  // 创建实例对象  i = (instanceOop)Universe::heap()->obj_allocate(this, size, CHECK_NULL);  // 如果该对象重写了  finalize() 方法  if (has_finalizer_flag && !RegisterFinalizersAtInit) {    // JVM 这里就会调用 Finalizer 类的静态方法 register    // 将这个 Java 对象与 FinalReference 关联起来    i = register_finalizer(i, CHECK_NULL);  }  return i;}

final class Finalizer extends FinalReference<Object> {    static void register(Object finalizee) {        new Finalizer(finalizee);    }}

final class Finalizer extends FinalReference<Object> { 
    private static ReferenceQueue<Object> queue = new ReferenceQueue<>();
    // 双向链表，保存 JVM 堆中所有的 Finalizer 对象，防止 Finalizer 被 GC 掉    private static Finalizer unfinalized = null;
    private Finalizer next, prev;
    private Finalizer(Object finalizee) {        super(finalizee, queue);        // push onto unfinalized        synchronized (lock) {            if (unfinalized != null) {                this.next = unfinalized;                unfinalized.prev = this;            }            unfinalized = this;        }    }}

    Reference(T referent, ReferenceQueue<? super T> queue) {        // 被引用的普通 Java 对象        this.referent = referent;        //  Finalizer 中的 ReferenceQueue 实例（全局）        this.queue = (queue == null) ? ReferenceQueue.NULL : queue;    }

final class Finalizer extends FinalReference<Object> {     static {        ThreadGroup tg = Thread.currentThread().getThreadGroup();        // 获取 system thread group        for (ThreadGroup tgn = tg;             tgn != null;             tg = tgn, tgn = tg.getParent());        // 创建 system thread : FinalizerThread        Thread finalizer = new FinalizerThread(tg);        finalizer.setPriority(Thread.MAX_PRIORITY - 2);        finalizer.setDaemon(true);        finalizer.start();    }}