【Java】 DirectByteBuffer堆外内存回收（java内存回收程序负责释放无用内存）

　　本篇文章为你整理了【Java】 DirectByteBuffer堆外内存回收（java内存回收程序负责释放无用内存）的详细内容，包含有jvm 堆外内存回收 java内存回收程序负责释放无用内存 java内存回收机制原理简要介绍java的内存回收技术【Java】 DirectByteBuffer堆外内存回收，希望能帮助你了解【Java】 DirectByteBuffer堆外内存回收。

　　在分析堆外内存回收之前，先了解下PhantomReference虚引用。

　　PhantomReference需要与ReferenceQueue引用队列结合使用，在GC进行垃圾回收的时候，如果发现一个对象只有虚引用在引用它，则认为该对象需要被回收，会将引用该对象的虚引用加入到与其关联的ReferenceQueue队列中，开发者可以通过ReferenceQueue获取需要被回收的对象，然后做一些清理操作，从队列中获取过的元素会从队列中清除，之后GC就可以对该对象进行回收。

　　虚引用提供了一种追踪对象垃圾回收状态的机制，让开发者知道哪些对象准备进行回收，在回收之前开发者可以进行一些清理工作，之后GC就可以将对象进行真正的回收。

　　来看一个虚引用的使用例子：

　　创建一个ReferenceQueue队列queue，用于跟踪对象的回收；

　　创建一个obj对象，通过new创建的是强引用，只要强引用存在，对象就不会被回收；

　　创建一个虚引用PhantomReference，将obj对象和ReferenceQueue队列传入，此时phantomReference里面引用了obj对象，并关联着引用队列queue；

　　同样的方式创建另一个obj1对象和虚引用对象phantomReference1；

　　将obj置为NULL，此时强引用关系失效；

　　调用 System.gc()进行垃圾回收；

　　由于obj的强引用关系失效，所以GC认为该对象需要被回收，会将引用该对象的虚引用phantomReference对象放入到与其关联的引用队列queue中；

　　通过poll从引用队列queue中获取对象，可以发现会获取到phantomReference对象，poll获取之后会将对象从引用队列中删除，之后会被垃圾回收器回收；

　　obj1的强引用关系还在，所以从queue中并不会获取到；

 public static void main(String[] args) {

　　 // 创建引用队列

　　 ReferenceQueue Object queue = new ReferenceQueue Object

　　 // 创建obj对象

　　 Object obj = new Object();

　　 // 创建虚引用，虚引用引用了obj对象，并与queue进行关联

　　 PhantomReference Object phantomReference = new PhantomReference Object (obj, queue);

　　 // 创建obj1对象

　　 Object obj1 = new Object();

　　 PhantomReference Object phantomReference1 = new PhantomReference Object (obj1, queue);

　　 // 将obj置为NULL，强引用关系失效

　　 obj = null;

　　 // 垃圾回收

　　 System.gc();

　　 // 从引用队列获取对象

　　 Object o = queue.poll();

　　 if (null != o) {

　　 System.out.println(o.toString());

　　输出结果：

java.lang.ref.PhantomReference@277c0f21

　　Reference实例的几种状态

　　Active：初始状态，创建一个Reference类型的实例之后处于Active状态，以上面虚引用为例，通过new创建一个PhantomReference虚引用对象之后，虚引用对象就处于Active状态。

　　Pending：当GC检测到对象的可达性发生变化时，会根据是否关联了引用队列来决定是否将状态更改为Pending或者Inactive，虚引用必须与引用队列结合使用，所以对于虚引用来说，如果它实际引用的对象需要被回收，垃圾回收器会将这个虚引用对象加入到一个Pending列表中，此时处于Pending状态。

　　同样以上面的的虚引用为例，因为obj的强引用关系失效，GC就会把引用它的虚引用对象放入到pending列表中。

　　Enqueued：表示引用对象被加入到了引用队列，Reference有一个后台线程去检测是否有处于Pending状态的引用对象，如果有会将引用对象加入到与其关联的引用队列中，此时由Pending转为Enqueued状态表示对象已加入到引用队列中。

　　Inactive：通过引用队列的poll方法可以从引用队列中获取引用对象，同时引用对象会从队列中移除，此时引用对象处于Inactive状态，之后会被GC回收。

　　DirectByteBuffer堆外内存回收

　　在DirectByteBuffer的构造函数中，在申请内存之前，先调用了Bits的reserveMemory方法回收内存，申请内存之后，调用Cleaner的create方法创建了一个Cleaner对象，并传入了当前对象（DirectByteBuffer）和一个Deallocator类型的对象：

class DirectByteBuffer extends MappedByteBuffer implements DirectBuffer {

　　 private final Cleaner cleaner;

　　 DirectByteBuffer(int cap) { // package-private

　　 super(-1, 0, cap, cap);

　　 boolean pa = VM.isDirectMemoryPageAligned();

　　 int ps = Bits.pageSize();

　　 long size = Math.max(1L, (long)cap + (pa ? ps : 0));

　　 // 清理内存

　　 Bits.reserveMemory(size, cap);

　　 long base = 0;

　　 try {

　　 // 分配内存

　　 base = unsafe.allocateMemory(size);

　　 } catch (OutOfMemoryError x) {

　　 Bits.unreserveMemory(size, cap);

　　 throw x;

　　 unsafe.setMemory(base, size, (byte) 0);

　　 if (pa (base % ps != 0)) {

　　 // Round up to page boundary

　　 address = base + ps - (base (ps - 1));

　　 } else {

　　 address = base;

　　 // 创建Cleader，传入了当前对象和Deallocator

　　 cleaner = Cleaner.create(this, new Deallocator(base, size, cap));

　　 att = null;

　　Cleaner从名字上可以看出与清理有关，Bits的reserveMemory方法底层也是通过Cleaner来进行清理，所以Cleaner是重点关注的类。

　　Deallocator是DirectByteBuffer的一个内部类，并且实现了Runnable接口，在run方法中可以看到对内存进行了释放，接下来就去看下在哪里触发Deallocator任务的执行：

class DirectByteBuffer extends MappedByteBuffer implements DirectBuffer {

　　 private static class Deallocator implements Runnable {

　　 // ...

　　 private Deallocator(long address, long size, int capacity) {

　　 assert (address != 0);

　　 this.address = address; // 设置内存地址

　　 this.size = size;

　　 this.capacity = capacity;

　　 public void run() {

　　 if (address == 0) {

　　 // Paranoia

　　 return;

　　 // 释放内存

　　 unsafe.freeMemory(address);

　　 address = 0;

　　 Bits.unreserveMemory(size, capacity);

　　Cleaner

　　Cleaner继承了PhantomReference，PhantomReference是Reference的子类，所以Cleaner是一个虚引用对象。

　　创建Cleaner

　　虚引用需要与引用队列结合使用，所以在Cleaner中可以看到有一个ReferenceQueue，它是一个静态的变量，所以创建的所有Cleaner对象都会共同使用这个引用队列。

　　在创建Cleaner的create方法中，处理逻辑如下：

　　通过构造函数创建了一个Cleaner对象，构造函数中的referent参数为DirectByteBuffer，thunk参数为Deallocator对象，在构造函数中又调用了父类的构造函数完成实例化；

　　调用add方法将创建的Cleaner对象加入到链表中，添加到链表的时候使用的是头插法，新加入的节点放在链表的头部，first成员变量是一个静态变量，它指向链表的头结点，创建的Cleaner都会加入到这个链表中；

　　创建后的Cleaner对象处于Active状态。

 public class Cleaner extends PhantomReference Object {

　　 // ReferenceQueue队列

　　 private static final ReferenceQueue Object dummyQueue = new ReferenceQueue ();

　　 // 静态变量，链表的头结点，创建的Cleaner都会加入到这个链表中

　　 static private Cleaner first = null;

　　 // thunk

　　 private final Runnable thunk;

　　 public static Cleaner create(Object ob, Runnable thunk) {

　　 if (thunk == null)

　　 return null;

　　 // 创建一个Cleaner并加入链表

　　 return add(new Cleaner(ob, thunk));

　　 private Cleaner(Object referent, Runnable thunk) {

　　 super(referent, dummyQueue); // 调用父类构造函数，传入引用对象和引用队列

　　 this.thunk = thunk; // thunk指向传入的Deallocator

　　 private static synchronized Cleaner add(Cleaner cl) {

　　 // 如果头结点不为空

　　 if (first != null) {

　　 // 将新加入的节点作为头结点

　　 cl.next = first;

　　 first.prev = cl;

　　 first = cl;

　　 return cl;

　　Cleaner调用父类构造函数时，最终会进入到父类Reference中的构造函数中：

　　referent：指向实际的引用对象，上面创建的是DirectByteBuffer，所以这里指向的是DirectByteBuffer。

　　queue：引用队列，指向Cleaner中的引用队列dummyQueue。

public class PhantomReference T extends Reference T {

　　 // ...

　　 public PhantomReference(T referent, ReferenceQueue ? super T q) {

　　 super(referent, q); // 调用父类构造函数

　　public abstract class Reference T {

　　 /* 引用对象 */

　　 private T referent;

　　 // 引用队列

　　 volatile ReferenceQueue ? super T queue;

　　 Reference(T referent, ReferenceQueue ? super T queue) {

　　 this.referent = referent;

　　 // 设置引用队列

　　 this.queue = (queue == null) ? ReferenceQueue.NULL : queue;

　　启动ReferenceHandler线程

　　Reference中有一个静态方法，里面创建了一个ReferenceHandler并设置为守护线程，然后启动了该线程，并创建了JavaLangRefAccess对象设置到SharedSecrets中：

public abstract class Reference T {

　　 static {

　　 ThreadGroup tg = Thread.currentThread().getThreadGroup();

　　 for (ThreadGroup tgn = tg;

　　 tgn != null;

　　 tg = tgn, tgn = tg.getParent());

　　 // 创建ReferenceHandler

　　 Thread handler = new ReferenceHandler(tg, "Reference Handler");

　　 // 设置优先级为最高

　　 handler.setPriority(Thread.MAX_PRIORITY);

　　 handler.setDaemon(true);

　　 handler.start();

　　 // 这里设置了JavaLangRefAccess

　　 SharedSecrets.setJavaLangRefAccess(new JavaLangRefAccess() {

　　 @Override

　　 public boolean tryHandlePendingReference() {

　　 // 调用了tryHandlePending

　　 return tryHandlePending(false);

　　ReferenceHandler是Reference的内部类，继承了Thread，在run方法中开启了一个循环，不断的执行tryHandlePending方法，处理Reference中的pending列表：

public abstract class Reference T {

　　 private static class ReferenceHandler extends Thread {

　　 // ...

　　 ReferenceHandler(ThreadGroup g, String name) {

　　 super(g, name);

　　 public void run() {

　　 while (true) {

　　 // 处理pending列表

　　 tryHandlePending(true);

　　Cleaner会启动一个优先级最高的守护线程，不断调用tryHandlePending来检测是否有需要回收的引用对象(还未进行真正的回收)，然后进行处理。

　　处理pending列表

　　垃圾回收器会将要回收的引用对象放在Reference的pending变量中，从数据类型上可以看出pending只是一个Reference类型的对象，并不是一个list，如果有多个需要回收的对象，如何将它们全部放入pending对象中？

　　可以把pengding看做是一个链表的头结点，假如有引用对象被判定需要回收，如果pengding为空直接放入即可，如果不为空，将使用头插法将新的对象加入到链表中，也就是将新对象的discovered指向pending对象，然后将pending指向当前要回收的这个对象，这样就形成了一个链表，pending指向链表的头结点。

　　在pending链表中的引用对象处于pending状态。

　　接下来看tryHandlePending方法的处理逻辑：

　　
如果pending不为空，表示有需要回收的对象，此时将pengding指向的对象放在临时变量r中，并判断是否是Cleaner类型，如果是将其强制转为Cleaner，记录在临时变量c中，接着更新pending的值为r的discovered，因为discovered中记录了下一个需要被回收的对象，pengding需要指向下一个需要被回收的对象；

　　pending如果为NULL，会进入到else的处理逻辑，返回值为参数传入的waitForNotify的值。

　　
// 静态变量pending列表，可以看做是一个链表，pending指向链表的头结点

　　 private static Reference Object pending = null;

　　 static boolean tryHandlePending(boolean waitForNotify) {

　　 Reference Object

　　 Cleaner c;

　　 try {

　　 synchronized (lock) {

　　 // 如果pending不为空

　　 if (pending != null) {

　　 // 获取pending执行的对象

　　 r = pending;

　　 // 如果是Cleaner类型

　　 c = r instanceof Cleaner ? (Cleaner) r : null;

　　 // 将pending指向下一个节点

　　 pending = r.discovered;

　　 // 将discovered置为空

　　 r.discovered = null;

　　 } else {

　　 // 等待

　　 if (waitForNotify) {

　　 lock.wait();

　　 return waitForNotify;

　　 } catch (OutOfMemoryError x) {

　　 Thread.yield();

　　 // retry

　　 return true;

　　 } catch (InterruptedException x) {

　　 // retry

　　 return true;

　　 if (c != null) {

　　 // 调用clean方法进行清理

　　 c.clean();

　　 return true;

　　 // 获取引用队列

　　 ReferenceQueue ? super Object q = r.queue;

　　 // 如果队列不为空，将对象加入到引用队列中

　　 if (q != ReferenceQueue.NULL) q.enqueue(r);

　　 // 返回true

　　 return true;

　　在Cleaner的clean方法中，可以看到，调用了thunk的run方法，前面内容可知，thunk指向的是Deallocator对象，所以会执行Deallocator的run方法，Deallocator的run方法前面也已经看过，里面会对DirectByteBuffer的堆外内存进行释放：

public class Cleaner extends PhantomReference Object {

　　 public void clean() {

　　 if (!remove(this))

　　 return;

　　 try {

　　 // 调用run方法

　　 thunk.run();

　　 } catch (final Throwable x) {

　　 AccessController.doPrivileged(new PrivilegedAction Void () {

　　 public Void run() {

　　 if (System.err != null)

　　 new Error("Cleaner terminated abnormally", x)

　　 .printStackTrace();

　　 System.exit(1);

　　 return null;

　　 }});

　　总结

　　Cleaner是一个虚引用，它实际引用的对象DirectByteBuffer如果被GC判定为需要回收，会将引用该对象的Cleaner加入到pending列表，ReferenceHandler线程会不断检测pending是否为空，如果不为空，就对其进行处理：

　　如果对象类型为Cleaner，就调用Cleaner的clean方法进行清理，Cleaner的clean方法又会调用Deallocator的run方法，里面调用了freeMemory方法对DirectByteBuffer分配的堆外内存进行释放；

　　将Cleaner对象加入到与其关联的引用队列中；

　　ReferenceQueue名字听起来是一个队列，实际使用了一个链表，使用头插法将加入的节点串起来，ReferenceQueue中的head变量指向链表的头节点，每个节点是一个Reference类型的对象：

public class ReferenceQueue T {

　　 // head为链表头节点

　　 private volatile Reference ? extends T head = null;

　　Reference中除了discovered变量之外，还有一个next变量，discovered指向的是处于pending状态时pending列表中的下一个元素，next变量指向的是处于Enqueued状态时，引用队列中的下一个元素：

public abstract class Reference T {

　　 /* When active: 处于active状态时为NULL

　　 * pending: this

　　 * Enqueued: Enqueued状态时，指向引用队列中的下一个元素

　　 * Inactive: this

　　 @SuppressWarnings("rawtypes")

　　 Reference next;

　　 /* When active: active状态时，指向GC维护的一个discovered链表中的下一个元素

　　 * pending: pending状态时，指向pending列表中的下一个元素

　　 * otherwise: 其他情况为NULL

　　 transient private Reference T discovered; /* used by VM */

　　enqueue入队

　　进入引用队列中的引用对象处于enqueue状态。

　　enqueue的处理逻辑如下：

　　判断要加入的对象关联的引用队列，对队列进行判断，如果队列为空或者队列等于ReferenceQueue中的空队列ENQUEUED，表示该对象之前已经加入过队列，不能重复操作，返回false，如果未加入过继续下一步；

　　将对象所关联的引用队列置为ENQUEUED，它是一个空队列，表示节点已经加入到队列中；

　　判断头节点是否为空，如果为空，表示链表还没有节点，将当前对象的next指向自己，如果头结点不为空，将当前对象的next指向头结点，然后更新头结点的值为当前对象（头插法插入链表）；

　　增加队列的长度，也就是链表的长度；

public class ReferenceQueue T {

　　 // 空队列

　　 static ReferenceQueue Object ENQUEUED = new Null ();

　　 // 入队，将节点加入引用队列，队列实际上是一个链表

　　 boolean enqueue(Reference ? extends T r) {

　　 synchronized (lock) {

　　 // 获取关联的引用队列

　　 ReferenceQueue ? queue = r.queue;

　　 // 如果为空或者已经添加到过队列

　　 if ((queue == NULL) (queue == ENQUEUED)) {

　　 return false;

　　 assert queue == this;

　　 // 将引用队列置为一个空队列，表示该节点已经入队

　　 r.queue = ENQUEUED;

　　 // 如果头结点为空将下一个节点置为自己，否则将next置为链表的头结点，可以看出同样使用的是头插法将节点插入链表

　　 r.next = (head == null) ? r : head;

　　 // 更新头结点为当前节点

　　 head = r;

　　 // 增加长度

　　 queueLength++;

　　 if (r instanceof FinalReference) {

　　 sun.misc.VM.addFinalRefCount(1);

　　 lock.notifyAll();

　　 return true;

　　poll出队

　　在调用poll方法从引用队列中获取一个元素并出队的时候，首先对head头结点进行判空，如果为空表示引用队列中没有数据，返回NULL，否则调用reallyPoll从引用队列中获取元素。

　　出队的处理逻辑如下：

　　
如果头节点的下一个节点是自己，表示链表只有一个节点，头结点出队之后链表为空，所以将头结点的值更新为NULL；

　　如果头节点的下一个节点不是自己，表示链表中还有其他节点，更新head头节点的值为下一个节点，也就是next指向的对象；

　　
从出队的逻辑中可以看出，引用队列中的对象是后进先出的，poll出队之后的引用对象处于Inactive状态，表示可以被GC回收掉。

public class ReferenceQueue T {

　　 * 从引用队列中获取一个节点，进行出队操作

　　 public Reference ? extends T poll() {

　　 // 如果头结点为空，表示没有数据

　　 if (head == null)

　　 return null;

　　 synchronized (lock) {

　　 return reallyPoll();

　　 @SuppressWarnings("unchecked")

　　 private Reference ? extends T reallyPoll() { 、 /* Must hold lock */

　　 // 获取头结点

　　 Reference ? extends T r = head;

　　 if (r != null) {

　　 // 如果头结点的下一个节点是自己，表示链表只有一个节点，head置为null，否则head值为r的下一个节点，也就是next指向的对象

　　 head = (r.next == r) ?

　　 null :

　　 r.next;

　　 // 将引用队列置为NULL

　　 r.queue = NULL;

　　 // 下一个节点置为自己

　　 r.next = r;

　　 // 长度减一

　　 queueLength--;

　　 if (r instanceof FinalReference) {

　　 sun.misc.VM.addFinalRefCount(-1);

　　 // 返回链表中的第一个节点

　　 return r;

　　 return null;

　　reserveMemory内存清理

　　最开始在DirectByteBuffer的构造函数中看到申请内存之前会调用Bits的reserveMemory方法，如果没有足够的内存，它会从SharedSecrets获取JavaLangRefAccess对象进行一些处理，由前面的内容可知，Reference中的静态方法启动ReferenceHandler之后，创建了JavaLangRefAccess并设置到SharedSecrets中，所以这里调用JavaLangRefAccess的tryHandlePendingReference实际上依旧调用的是Reference中的tryHandlePending方法。

　　在调用Reference中的tryHandlePending方法处理需要回收的对象之后，调用tryReserveMemory方法判断是否有足够的内存，如果内存依旧不够，会调用` System.gc()触发垃圾回收，然后开启一个循环，处理逻辑如下：

　　
调用tryHandlePendingReference处理penging列表中的引用对象，前面在处理pending列表的逻辑中可以知道，如果pending列表不为空，会返回true，tryHandlePendingReference也会返回true，此时意味着清理了一部分对象，所以重新进入到第1步进行检查；

　　如果pending列表为空，会返回参数中传入的waitForNotify的值，从JavaLangRefAccess的tryHandlePendingReference中可以看出这里传入的是false，所以会进行如下处理：

　　通过 Thread.sleep(sleepTime)让当前线程睡眠一段时间，这样可以避免reserveMemory方法一直在占用资源;

　　对睡眠次数加1;

　　
reserveMemory方法的作用是保证在申请内存之前有足够的内存，如果没有足够的内存会进行清理，达到指定清理次数之后依旧没有足够的内存空间，将抛出OutOfMemoryError异常。

class Bits {

　　 static void reserveMemory(long size, int cap) {

　　 if (!memoryLimitSet VM.isBooted()) {

　　 maxMemory = VM.maxDirectMemory();

　　 memoryLimitSet = true;

　　 // 是否有足够内存

　　 if (tryReserveMemory(size, cap)) {

　　 return;

　　 // 获取JavaLangRefAccess

　　 final JavaLangRefAccess jlra = SharedSecrets.getJavaLangRefAccess();

　　 // 调用tryHandlePendingReference

　　 while (jlra.tryHandlePendingReference()) {

　　 // 判断是否有足够的内存

　　 if (tryReserveMemory(size, cap)) {

　　 return;

　　 // 调用gc进行垃圾回收

　　 System.gc();

　　 boolean interrupted = false;

　　 try {

　　 long sleepTime = 1;

　　 int sleeps = 0;

　　 // 开启循环

　　 while (true) {

　　 // 是否有足够内存

　　 if (tryReserveMemory(size, cap)) {

　　 return;

　　 // 如果次数小于最大限定次数，终止

　　 if (sleeps = MAX_SLEEPS) {

　　 break;

　　 // 再次处理penging列表中的对象

　　 if (!jlra.tryHandlePendingReference()) {

　　 try {

　　 // 睡眠一段时间

　　 Thread.sleep(sleepTime);

　　 sleepTime = 1;

　　 sleeps++; // 睡眠次数增加1

　　 } catch (InterruptedException e) {

　　 interrupted = true;

　　 // 抛出OutOfMemoryError异常

　　 throw new OutOfMemoryError("Direct buffer memory");

　　 } finally {

　　 if (interrupted) {

　　 // dont swallow interrupts

　　 Thread.currentThread().interrupt();

　　public abstract class Reference T {

　　 static {

　　 // ...

　　 // 这里设置了JavaLangRefAccess

　　 SharedSecrets.setJavaLangRefAccess(new JavaLangRefAccess() {

　　 @Override

　　 public boolean tryHandlePendingReference() {

　　 // 调用tryHandlePending,这里waitForNotify参数传入的是false

　　 return tryHandlePending(false);

　　参考

　　Reference源码解析

　　一文读懂java中的Reference和引用类型

　　Java 源码剖析——彻底搞懂 Reference 和 ReferenceQueue

　　以上就是【Java】 DirectByteBuffer堆外内存回收（java内存回收程序负责释放无用内存）的详细内容，想要了解更多【Java】 DirectByteBuffer堆外内存回收的内容，请持续关注盛行IT软件开发工作室。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

相关文章阅读