JDK源码分析（7）之 Reference 框架概览

对于Reference类大家可能会比较陌生，平时用的也比较少，对他的印象可能仅停在面试的时候查看引用相关的知识点；但在仔细查看源码后发现Reference还是非常实用的，平时我们使用的类都是强引用的，它的回收完全依赖于 GC；但是对于有些类我们想要自己控制的时候就比较麻烦，比如我想在内存还足够的时候就保留，不够的时候就回收，这时使用Reference就能够十分灵活的控制类的存亡了。

一、类定义

/**
 * Abstract base class for reference objects.  This class defines the
 * operations common to all reference objects.  Because reference objects are
 * implemented in close cooperation with the garbage collector, this class may
 * not be subclassed directly.
 *
 * @author Mark Reinhold
 * @since 1.2
 */
public abstract class Reference<T> {}

从注释和类图中可以清楚的看到：

  • Reference类是直接配合GC操作的，所以不能直接子类化，但是可以继承Reference的子类；
  • Reference类定义了子类的主要逻辑，所以在SoftReference、WeakReference和PhantomReference中几乎完全复用了Reference的逻辑；

二、Reference 框架结构

如图所示，Reference 的处理流程相当于事件处理

  1. 如果 new Reference 的时候如果没有传入 ReferenceQueue，相当于使用 JVM 的默认处理流程，达到一定条件的时候由GC回收；
  2. 如果 new Reference 的时候传入了 ReferenceQueue，相当于使用自定义的事件处理流程，此时的 ReferenceQueue 相当于事件监听器，Reference 则相当于每个事件，GC 标记的时候添加 discovered链表 相当于事件发现过程，pending和enqueued则相当于注册事件的过程，最后需要用户自定义事件处理逻辑；

在 Reference 的生命周期里面，一共有四个状态：

  • Active：每个引用的创建之初都是活动状态，直到下次 GC 的时候引用的强弱关系发生变化，同时不同的引用根据不同的策略改变状态；
  • Pending：正准备加入引用链表；
  • Enqueued：已经加入引用链表，相当于已经注册成功等待处理；
  • Inactive：所有的引用对象的终点，可回收状态；

三、可达性分析

上面我们提到当引用强弱关系发生变化的时候，他的状态会发生改变，那么这个强弱关系是如何判断的呢？
熟悉 JVM 的同学应该知道判断对象是否存活的算法大致有两种；

  1. 引用计数法，即每当有一个对象引用他的时候就加1，引用失效时减1，当任何时候计数都为0时，就代表对象可以被回收了；
  2. 可达性分析法，即从一组 GC Roots 对象出发，引用可达即代表存活，引用不可达就代表是可回收对象；如图所示：

上图仅表示了，强引用的回收，当加入了软引用，弱引用和虚应用之后：

  • 单路径中，以最弱的引用为准
  • 多路径中，以最强的引用为准

已上图为例：

  • 对于 Obj 1：单路径可达，所以 GC Roots 到 Obj 1为弱引用；
  • 对于 Obj 5：多路径可达，所以 GC Roots 到 Obj 5为软引用；

四、成员变量和构造函数

private T referent; /* Treated specially by GC */
volatile ReferenceQueue<? super T> queue;
volatile Reference next;
transient private Reference<T> discovered; /* used by VM */
private static Reference<Object> pending = null;

Reference(T referent) {
  this(referent, null);
}

Reference(T referent, ReferenceQueue<? super T> queue) {
  this.referent = referent;
  this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
}
  • referent：引用指向的对象，即需要Reference包装的对象；
  • queue：虽然ReferenceQueue的名字里面有队列，但是它的内部却没有包含任何队列和链表的结构；他的内部封装了单向链表的添加，删除和遍历等操作，实际作用相当于事件监听器；
  • next：引用单向链表；
  • discovered：discovered单向链表，由 JVM 维护；在 GC 标记的时候，当引用强弱关系达到一定条件时，由 JVM 添加；需要注意的是这个字段是 transient 修饰的，但是 Reference 类声明的时候却没有实现 Serializable 接口，这是因为 Reference 子类的子类可能实现 Serializable 接口，另外一般情况下也不建议实现 Serializable 接口；
  • pending：表示正在排队等待入队的引用；

五、重要函数

1. 初始化

static {
  ThreadGroup tg = Thread.currentThread().getThreadGroup();
  for (ThreadGroup tgn = tg;
    tgn != null;
    tg = tgn, tgn = tg.getParent());
  Thread handler = new ReferenceHandler(tg, "Reference Handler");
  /* If there were a special system-only priority greater than
   * MAX_PRIORITY, it would be used here
   */
  handler.setPriority(Thread.MAX_PRIORITY);
  handler.setDaemon(true);
  handler.start();

  // provide access in SharedSecrets
  SharedSecrets.setJavaLangRefAccess(new JavaLangRefAccess() {
    @Override
    public boolean tryHandlePendingReference() {
      return tryHandlePending(false);
    }
  });
}

可以看到在初始化的时候首先得到了层级最高的线程组即 System线程组，然后在里面加入了一个名为 “Reference Handler” 的 优先级最高 的 ReferenceHandler 线程；
接下来的一段代码是用于保证 JVM 在抛出 OOM 之前，原子性的清除非强引用的所有引用，如果空间仍然不足才会抛出 OOM；其中 SharedSecrets用于访问类的私有变量，于反射不同的是，它不会创建新的对象；比如：

package java.nio;
// Class Bits
static void reserveMemory(long size, int cap) {
  ...
  // optimist!
  if (tryReserveMemory(size, cap)) {
    return;
  }

  // 走到这里就说明空间已经不足了
  final JavaLangRefAccess jlra = SharedSecrets.getJavaLangRefAccess();

  // retry while helping enqueue pending Reference objects
  // which includes executing pending Cleaner(s) which includes
  // Cleaner(s) that free direct buffer memory
  while (jlra.tryHandlePendingReference()) {
   if (tryReserveMemory(size, cap)) {
     return;
   }
  }
  ...
}

有关 “Reference Handler” 的线程信息可以使用jstack [] <pid>抓取栈信息查看：

"Reference Handler" #2 daemon prio=10 os_prio=0 tid=0x00007fa1ac154170 nid=0x32a7 in Object.wait() [0x00007fa19661f000]
   java.lang.Thread.State: WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:502)
    at java.lang.ref.Reference.tryHandlePending(Reference.java:191)
    - locked <0x00000006c7e79bc0> (a java.lang.ref.Reference$Lock)
    at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:153)

2. ReferenceHandler 线程

private static class ReferenceHandler extends Thread {
  private static void ensureClassInitialized(Class<?> clazz) {
    try {
      Class.forName(clazz.getName(), true, clazz.getClassLoader());
    } catch (ClassNotFoundException e) {
      throw (Error) new NoClassDefFoundError(e.getMessage()).initCause(e);
    }
  }

  static {
    // pre-load and initialize InterruptedException and Cleaner classes
    // so that we don't get into trouble later in the run loop if there's
    // memory shortage while loading/initializing them lazily.
    ensureClassInitialized(InterruptedException.class);
    ensureClassInitialized(Cleaner.class);
  }

  ReferenceHandler(ThreadGroup g, String name) {
    super(g, name);
  }

  public void run() {
    while (true) {
      tryHandlePending(true);
    }
  }
}

可以看到这个线程只做了一件很简单的事情：

  • 首先确保InterruptedException和Cleaner已经加载，关于Cleaner就是一个虚引用的实际应用，后面还会详细讲到；
  • 然后死循环执行tryHandlePending；

3. tryHandlePending 核心方法

/**
 * Try handle pending {@link Reference} if there is one.<p>
 * Return {@code true} as a hint that there might be another
 * {@link Reference} pending or {@code false} when there are no more pending
 * {@link Reference}s at the moment and the program can do some other
 * useful work instead of looping.
 *
 * @param waitForNotify if {@code true} and there was no pending
 *                      {@link Reference}, wait until notified from VM
 *                      or interrupted; if {@code false}, return immediately
 *                      when there is no pending {@link Reference}.
 * @return {@code true} if there was a {@link Reference} pending and it
 *         was processed, or we waited for notification and either got it
 *         or thread was interrupted before being notified;
 *         {@code false} otherwise.
 */
static boolean tryHandlePending(boolean waitForNotify) {
  Reference<Object> r;
  Cleaner c;
  try {
    synchronized (lock) {
      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 {
        // 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;
}

这个方法主要完成了discovered -> pending -> enqueued的整个入队注册流程；值得注意的是虽然Cleaner是虚引用，但是它并不会入队，而是直接执行clean操作，也就意味着在使用Cleaner的时候不需要在起一个线程监听ReferenceQueue了；

4. ReferenceQueue 概览

static ReferenceQueue<Object> NULL = new Null<>();

// 用于标记是否已经入队，防止重复入队
static ReferenceQueue<Object> ENQUEUED = new Null<>();
private volatile Reference<? extends T> head = null;
private long queueLength = 0;

// reference入队操作
boolean enqueue(Reference<? extends T> r) { /* Called only by Reference class */

// poll 移除reference链表头元素
public Reference<? extends T> poll() { }

// 移除reference链表下一个元素
public Reference<? extends T> remove(long timeout) { }
public Reference<? extends T> remove() throws InterruptedException { }
void forEach(Consumer<? super Reference<? extends T>> action) { }

从上面的代码也可以看出ReferenceQueue的确没有包含任何链表或者队列的结构，但是封装了单向的链表的操作；

总结

  • Reference 主要用于更加灵活的控制对象的生死，其实现类似于事件处理，可以是 JVM 默认处理，也可以是用户自定义的处理逻辑；
  • 在 Java 语言中 Reference 类定义了子类（SoftReference，WeakReference，PhantomReference）的主要逻辑，但是判断引用回收的条件主要在 JVM 中定义（主要发生在 GC 标记阶段），如果你有兴趣可以到 OpenJDK 里面继续深入研究；
  • 如果在使用 Reference 的时候传入了 ReferenceQueue，即使用自定义的逻辑处理，那么最后一定要把 ReferenceQueue 中注册的 Reference 移除，因为此时 GC 不会回收 ReferenceQueue 中的链表；

原文地址：https://www.cnblogs.com/sanzao/p/10337291.html

时间： 2024-10-11 08:06:35

JDK源码分析（7）之 Reference 框架概览的相关文章

JDK源码分析—— ArrayBlockingQueue 和 LinkedBlockingQueue

目的:本文通过分析JDK源码来对比ArrayBlockingQueue 和LinkedBlockingQueue,以便日后灵活使用. 1. 在Java的Concurrent包中,添加了阻塞队列BlockingQueue,用于多线程编程.BlockingQueue的核心方法有: boolean add(E e) ,把 e 添加到BlockingQueue里.如果BlockingQueue可以容纳,则返回true,否则抛出异常. boolean offer(E e),表示如果可能的话,将 e 加到B

JDK源码分析之String篇

------------------------------String在内存中的存储情况(一下内容摘自参考资料1)----------------------------------- 前提:先了解下什么是声明,什么时候才算是产生了对象实例 其中x并未看到内存分配,变量在使用前必须先声明,再赋值,然后才可以使用.java基础数据类型会用对应的默认值进行初始化 一.首先看看Java虚拟机JVM的内存块及其变量.对象内存空间是怎么存储分配的 1.栈:存放基本数据类型及对象变量的引用,对象本身不存放

【E2LSH源码分析】LSH算法框架分析

位置敏感哈希(Locality Sensitive Hashing,LSH)是近似最近邻搜索算法中最流行的一种,它有坚实的理论依据并且在高维数据空间中表现优异.由于网络上相关知识的介绍比较单一,现就LSH的相关算法和技术做一介绍总结,希望能给感兴趣的朋友提供便利,也希望有兴趣的同道中人多交流.多指正. 1.LSH原理 最近邻问题(nearest neighbor problem)可以定义如下:给定n个对象的集合并建立一个数据结构,当给定任意的要查询对象时,该数据结构返回针对查询对象的最相似的数据

【JDK源码分析】通过源码分析CyclicBarrier

前言 CyclicBarrier它是什么?一个同步辅助类,它允许一组线程互相等待,直到到达某个公共屏障点.类似于朋友之间联系要在中午聚个会,几个朋友全部到齐后才开始喝酒吃菜. 源码 CyclicBarrier属性和构造器 public class CyclicBarrier { // 互斥锁 private final ReentrantLock lock = new ReentrantLock(); // 条件等待 private final Condition trip = lock.new

【JDK】JDK源码分析-CountDownLatch

概述 CountDownLatch 是并发包中的一个工具类,它的典型应用场景为:一个线程等待几个线程执行,待这几个线程结束后,该线程再继续执行. 简单起见,可以把它理解为一个倒数的计数器:初始值为线程数,每个线程结束时执行减 1 操作,当计数器减到 0 时等待的线程再继续执行. 代码分析 CountDownLatch 的类签名和主要方法如下: public class CountDownLatch {} 常用方法为:await().await(long, TimeUnit) 和 countDow

【JDK】JDK源码分析-Semaphore

概述 Semaphore 是并发包中的一个工具类,可理解为信号量.通常可以作为限流器使用,即限制访问某个资源的线程个数,比如用于限制连接池的连接数. 打个通俗的比方,可以把 Semaphore 理解为一辆公交车:车上的座位数(初始的“许可” permits 数量)是固定的,行驶期间如果有人上车(获取许可),座位数(许可数量)就会减少,当人满的时候不能再继续上车了(获取许可失败):而有人下车(释放许可)后就空出了一些座位,其他人就可以继续上车了. 下面具体分析其代码实现. 代码分析 Semapho

Java中集合框架，Collection接口、Set接口、List接口、Map接口，已经常用的它们的实现类，简单的JDK源码分析底层实现

(一)集合框架: Java语言的设计者对常用的数据结构和算法做了一些规范(接口)和实现(实现接口的类).所有抽象出来的数据结构和操作(算法)统称为集合框架. 程序员在具体应用的时候,不必考虑数据结构和算法实现细节,只需要用这些类创建一些对象,然后直接应用就可以了,这样就大大提高了编程效率. (二)集合框架包含的内容: (三)集合框架的接口(规范)   Collection接口:存储一组不唯一,无序的对象 List接口:存储一组不唯一,有序的对象 Set接口:存储一组唯一,无序的对象 Map接口:

JDK源码分析（8）之 Reference 实现和应用

在阅读本文之前最好对 Reference 框架有一个整体的把握,可以参考我上一篇博客 Reference 框架概览 :本文主要讲了 Reference 的子类实现和应用(SoftReference,WeakReference,PhantomReference): Java 引用的强弱关系:StrongReference > SoftReference > WeakReference > PhantomReference 一.StrongReference 强引用:我们通常使用的引用,形如

JDK源码分析之concurrent包（三） -- Future方式的实现

上一篇我们基于JDK的源码对线程池ThreadPoolExecutor的实现做了分析,本篇来对Executor框架中另一种典型用法Future方式做源码解读.我们知道Future方式实现了带有返回值的程序的异步调用,关于异步调用的场景大家可以自行脑补Ajax的应用(获取返回结果的方式不同,Future是主动询问获取,Ajax是回调函数),这里不做过多说明. 在进入源码前,首先来看下Future方式相关的API: 接口Callable:有返回结果并且可能抛出异常的任务: 接口Future:表示异步

JDK源码分析（9）之 WeakHashMap 相关

平时我们使用最多的数据结构肯定是 HashMap,但是在使用的时候我们必须知道每个键值对的生命周期,并且手动清除它:但是如果我们不是很清楚它的生命周期,这时候就比较麻烦:通常有这样几种处理方式: 由一个线程定时处理,可以是Timer或者ScheduledThreadPoolExecutor: 利用重写LinkedHashMap.removeEldestEntry(),实现 FIFOCache 或者 LRUCache:可以参考我之前写的一篇博客 LinkedHashMap 相关: 利用 WeakH