【Java】DirectByteBuffer 堆外内存源码解读

目录

一、DirectByteBuffer直接缓冲区介绍

1.1 如何使用DirectByteBuffer

1.2 DirectByteBuffer对象实例化过程

1.2.1 构造器

1.2.2 判断是否有足够的空间可供申请java.nio.Bits#reserveMemory

1.2.3 尝试申请内存

1.2.4 为什么要手动调用System.gc()

1.2.5 DirectByteBuffer实现内存分配

1.2.6 内存分配失败回收内存计数：java.nio.Bits#unreserveMemory 

1.2.7 内存分配小结

1.3 DirectByteBuffer读写逻辑 

 二、堆外内存回收

2.1 DirectByteBuffer及对应的堆外内存回收机制Cleaner

2.1.1 Cleaner对象的创建

2.2. 释放堆外内存

2.2.1 守护线程处理对象引用Reference以及ReferenceQueue

 2.2.2 如何触发Cleaner中的Deallocator线程释放内存

2.3 DirectByteBuffer有关的JVM选项

三、JVM使用堆外内存的原因

3.1 降低垃圾回收停顿提升性能

3.2 避免JVM大堆常驻无法回收

3.3 提升内存I/O减少内存数据拷贝

四、本节总结

---

作为Java程序开发者我们都知道编译好的程序需要在Java虚拟机中运行，需要分配内存空间指定堆的大小，通过-Xms2G -Xmx2G参数指定JVM启动堆内存的大小，这是堆内内存的分配。而Java程序往往在开发中需要通过JNI调用lib库，以及使用第三方开发框架，诸如mina,netty Nio框架，这些框架为了提高通信效率，减少内存拷贝减轻Jvm GC压力使用了堆外内存，我们从下图了解一下Java运行时所需内存的分配：

根据上图很直观的发现Java程序运行需要的内存分堆内内存(Heap)和堆外内存(No Heap)，本次介绍的DirectByteBuffer只是堆外内存的其中一部分，除此之外还有字节码、本地native方法调用、JVM运行本身所需内存等。

一、DirectByteBuffer直接缓冲区介绍

        DirectByteBuffer是ByteBuffer的一个实现，ByteBuffer有两个类实现，一类是HeapBuffer（堆内内存），另一类是DirectBuffer(堆外内存)

        

1.1 如何使用DirectByteBuffer

如果需要实例化一个DirectByteBuffer，可以使用java.nio.ByteBuffer#allocateDirect这个方法

public static ByteBuffer allocateDirect(int capacity) {

    return new DirectByteBuffer(capacity);

}

1.2 DirectByteBuffer对象实例化过程

1.2.1 构造器

我们来看一下DirectByteBuffer是如何构造，如何申请与释放内存的，先看看DirectByteBuffer的构造器

    DirectByteBuffer(int cap) {                   // package-private
        //初始化Buffer的四个核心属性
        super(-1, 0, cap, cap);
        //判断是否需要页面对齐，通过参数-XX:+PageAlignDirectMemory控制，默认为false
        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 {
            // 通过unsafe.allocateMemory分配堆外内存，并返回堆外内存的基地址
            base = unsafe.allocateMemory(size);
        } catch (OutOfMemoryError x) {
            // 分配失败，释放内存
            Bits.unreserveMemory(size, cap);
            throw x;
        }
        // 初始化内存空间为0
        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;
        }
        // 构建Cleaner对象用于跟踪DirectByteBuffer对象的垃圾回收，以实现当DirectByteBuffer被垃圾回收时，堆外内存也会被释放
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
        att = null;

    }

1.2.2 判断是否有足够的空间可供申请java.nio.Bits#reserveMemory

// 该方法主要用于判断申请的堆外内存是否超过了用例指定的最大值

// 如果还有足够空间可以申请，则更新对应的变量

// 如果已经没有空间可以申请，则抛出OutOfMemoryError
// 参数解释：

//     size：根据是否按页对齐，得到的真实需要申请的内存大小

//     cap：用户指定需要的内存大小(<=size)
static void reserveMemory(long size, int cap) {
        // 获取最大可以申请的对外内存大小，默认值是64MB
        // 可以通过参数-XX:MaxDirectMemorySize=设置这个大小
        // -XX:MaxDirectMemorySize限制的是用户申请的大小，而不考虑对齐情况
        if (!memoryLimitSet && VM.isBooted()) {
            maxMemory = VM.maxDirectMemory();
            memoryLimitSet = true;
        }

        // 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;
            }
        }

        // trigger VM's Reference processing
        // 如果已经没有足够空间，则尝试手动触发一次Full GC，触发释放堆外内存
        System.gc();

        // a retry loop with exponential back-off delays
        // (this gives VM some time to do it's job)
        boolean interrupted = false;
        try {
            long sleepTime = 1;
            int sleeps = 0;
            while (true) {
                if (tryReserveMemory(size, cap)) {
                    return;
                }
                if (sleeps >= MAX_SLEEPS) {
                    break;
                }
                if (!jlra.tryHandlePendingReference()) {
                    try {
                        Thread.sleep(sleepTime);
                        sleepTime <<= 1;
                        sleeps++;
                    } catch (InterruptedException e) {
                        interrupted = true;
                    }
                }
            }

            // no luck
            throw new OutOfMemoryError("Direct buffer memory");

        } finally {
            if (interrupted) {
                // don't swallow interrupts
                Thread.currentThread().interrupt();
            }
        }
    }

其中，如果系统中内存( 即，堆外内存 )不够的话：

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

jlra.tryHandlePendingReference()会触发一次非堵塞的Reference#tryHandlePending(false)。该方法会将已经被JVM垃圾回收的DirectBuffer对象的堆外内存释放。

1.2.3 尝试申请内存

java.nio.Bits#tryReserveMemory方法尝试计算可以分配的真实内存大小，如何可以申请，则更新以下参数：

• toalCapacity=toalCapacity+cap，目前用户已经申请的总空间大小；
• reservedMemory=reservedMemory+size，目前保留堆外内存总空间的大小；
• count：申请次数加1；

    // 参数解释：
    //     size：根据是否按页对齐，得到的真实需要申请的内存大小
    //     cap：用户指定需要的内存大小(<=size)
    private static boolean tryReserveMemory(long size, int cap) {

        // -XX:MaxDirectMemorySize limits the total capacity rather than the
        // actual memory usage, which will differ when buffers are page aligned.
        //     totalCapacity：目前用户已经申请的总空间
        //     maxMemory：堆外内存设置最大值
        //     reservedMemory：真实的目前保留的堆外内存空间
        long totalCap;
        while (cap <= maxMemory - (totalCap = totalCapacity.get())) {
            if (totalCapacity.compareAndSet(totalCap, totalCap + cap)) {
                reservedMemory.addAndGet(size);
                count.incrementAndGet();
                return true;
            }
        }

        return false;
    }

调用AtmoticLong#compareAndSet(long expect, long update)，最终实现通过Unsafe更新用户申请的总内存空间大小totalCapacity+cap，即unsafe.compareAndSwapLong(valueOffset,expect,update)

    /**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     *
     * @param expect the expected value
     * @param update the new value
     * @return {@code true} if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    public final boolean compareAndSet(long expect, long update) {
        return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
    }

1.2.4 为什么要手动调用System.gc()

        // trigger VM's Reference processing
        System.gc();

调用System.gc()，是想触发一次Full gc，当然前提是你没有显式的设置-XX:+DisableExplicitGC来禁用显式GC，否则System.gc()无效。并且你需要知道，调用System.gc()并不能够保证Full gc马上就能被执行。所以接下来while循环尝试了最大9次，如果还是没有足够内存则抛出OutOfMemoryError("Direct buffer memory”)异常。 

        try {
            long sleepTime = 1;
            int sleeps = 0;
            while (true) {
                if (tryReserveMemory(size, cap)) {
                    return;
                }
                // MAX_SLEEPS=9
                if (sleeps >= MAX_SLEEPS) {
                    break;
                }
                // 将已经被JVM垃圾回收的DirectBuffer对象的堆外内存释放
                if (!jlra.tryHandlePendingReference()) {
                    try {
                        Thread.sleep(sleepTime);
                        sleepTime <<= 1;
                        sleeps++;
                    } catch (InterruptedException e) {
                        interrupted = true;
                    }
                }
            }

            // Full Gc后内存还是不足则抛出异常
            throw new OutOfMemoryError("Direct buffer memory");

        } finally {
            if (interrupted) {
                // don't swallow interrupts
                Thread.currentThread().interrupt();
            }
        }

通过Full gc操作来触发回收堆外内存，不过我想先说的是堆外内存不会对gc造成什么影响(这里的System.gc除外)，但是堆外内存的回收其实依赖于我们的gc机制，首先我们要知道在java层面和我们在堆外分配的这块内存关联的只有与之关联的DirectByteBuffer对象了，它记录了这块内存的基地址以及大小，那么既然和gc也有关，那就是gc能通过操作DirectByteBuffer对象来间接操作对应的堆外内存了。

DirectByteBuffer对象在创建的时候关联了一个PhantomReference，说到PhantomReference它其实主要是用来跟踪对象何时被回收的，它不能影响gc决策，但是gc过程中如果发现某个对象除了只有PhantomReference引用它之外，并没有其他的地方引用它了，那将会把这个引用放到java.lang.ref.Reference.pending队列里，在gc完毕的时候通知ReferenceHandler这个守护线程去执行一些后置处理，而DirectByteBuffer关联的PhantomReference是PhantomReference的一个子类，在最终的处理里会通过Unsafe的free接口来释放DirectByteBuffer对应的堆外内存块

注意，这里之所以用使用full gc的很重要的一个原因是：System.gc()会对新生代的老生代都会进行内存回收，这样会比较彻底地回收DirectByteBuffer对象以及他们关联的堆外内存.
DirectByteBuffer对象本身其实是很小的，但是它后面可能关联了一个非常大的堆外内存，因此我们通常称之为冰山对象.
我们做ygc的时候会将新生代里的不可达的DirectByteBuffer对象及其堆外内存回收了，但是无法对old里的DirectByteBuffer对象及其堆外内存进行回收，这也是我们通常碰到的最大的问题。( 并且堆外内存多用于生命期中等或较长的对象 )
如果有大量的DirectByteBuffer对象移到了old，但是又一直没有做cms gc或者full gc，而只进行ygc，那么我们的物理内存可能被慢慢耗光，但是我们还不知道发生了什么，因为heap明明剩余的内存还很多(前提是我们禁用了System.gc – JVM参数DisableExplicitGC)。

总的来说，Bits.reserveMemory(size, cap)方法在可用堆外内存不足以分配给当前要创建的堆外内存大小时，会实现以下的步骤来尝试完成本次堆外内存的创建：
① 触发一次非堵塞的Reference#tryHandlePending(false)。该方法会将已经被JVM垃圾回收的DirectBuffer对象的堆外内存释放。
② 如果进行一次堆外内存资源回收后，还不够进行本次堆外内存分配的话，则进行 System.gc()。System.gc()会触发一个full gc，但你需要知道，调用System.gc()并不能够保证full gc马上就能被执行。所以在后面打代码中，会进行最多9次尝试，看是否有足够的可用堆外内存来分配堆外内存。并且每次尝试之前，都对延迟等待时间，已给JVM足够的时间去完成full gc操作。
注意，如果你设置了-XX:+DisableExplicitGC，将会禁用显示GC，这会使System.gc()调用无效。
③ 如果9次尝试后依旧没有足够的可用堆外内存来分配本次堆外内存，则抛出OutOfMemoryError("Direct buffer memory”)异常。

1.2.5 DirectByteBuffer实现内存分配

通过Bits.reserveMemory()方法判断可以分配内存，然后调用Unsafe.allocateMemory(cap)分配内存。

// 申请一块本地内存。内存空间是未初始化的，其内容是无法预期的。

// 使用freeMemory释放内存，使用reallocateMemory修改内存大小

public native long allocateMemory(long bytes);

// openjdk8/hotspot/src/share/vm/prims/unsafe.cpp

UNSAFE_ENTRY(jlong, Unsafe_AllocateMemory(JNIEnv *env, jobject unsafe, jlong size))

  UnsafeWrapper("Unsafe_AllocateMemory");

  size_t sz = (size_t)size;

  if (sz != (julong)size || size < 0) {

    THROW_0(vmSymbols::java_lang_IllegalArgumentException());

  }

  if (sz == 0) {

    return 0;

  }

  sz = round_to(sz, HeapWordSize);

  // 调用os::malloc申请内存，内部使用malloc函数申请内存

  void* x = os::malloc(sz, mtInternal);

  if (x == NULL) {

    THROW_0(vmSymbols::java_lang_OutOfMemoryError());

  }

  //Copy::fill_to_words((HeapWord*)x, sz / HeapWordSize);

  return addr_to_java(x);

UNSAFE_END

可以看出DirectByteBuffer构造函数，创建DirectByteBuffer的时候，通过sun.misc.Unsafe#allocateMemory使用malloc这个C标准库的函数来分配内存。

那么堆外内存空间分配的内存是系统本地内存，并不在Java的内存中，也不属于JVM管控范围，通过堆内对象DirectByteBuffer是怎么被操作堆外内存的呢？我们在DirectByteBuffer构造函数发现如下代码：

        // 设置堆外内存起始地址address
        if (pa && (base % ps != 0)) {
            // Round up to page boundary
            address = base + ps - (base & (ps - 1));
        } else {
            address = base;
        }

发现DirectByteBuffer的父类Buffer中有个address属性 ，在DirectByteBuffer初始化的时候进行赋值，address只会被DirectByteBuffer使用到。之所以将address属性升级放在Buffer中，是为了在JNI调用（native本地方法调用）GetDirectBufferAddress时提升它调用的速率。

1.2.6 内存分配失败回收内存计数：java.nio.Bits#unreserveMemory 

如果unsafe.allocateMemory(bytes)分配内存失败，则调用java.nio.Bits#unreserveMemory()方法恢复内存申请计数参数，则更新恢复以下参数：

• toalCapacity=toalCapacity-cap，目前用户已经申请的总空间大小；
• reservedMemory=reservedMemory-size，目前保留堆外内存总空间的大小；
• count：申请次数减1；

    static void unreserveMemory(long size, int cap) {
        long cnt = count.decrementAndGet();
        long reservedMem = reservedMemory.addAndGet(-size);
        long totalCap = totalCapacity.addAndGet(-cap);
        assert cnt >= 0 && reservedMem >= 0 && totalCap >= 0;
    }

1.2.7 内存分配小结

查阅了DirectByteBuffer构造函数会发现整个初始化过程包括内存申请、分配、初始化、回收。堆外内存回收是通过跟踪DirectByteBuffer对象的垃圾回收，以实现当DirectByteBuffer被垃圾回收时，分配的堆外内存一起被释放，本节后边接着介绍。DirectByteBuffer对象整个初始化过程如下：

1. Bits.reservedMemory();             申请真实的内存大小，并计数
2. Unsafe.allocateMemory(cap);        分配内存
3. Bits.unreserveMemory();            分配失败则重置申请参数
4. Unsafe.setMemory();                初始化内存
5. Unsafe.freeMemory();                                         释放内存

1.3 DirectByteBuffer读写逻辑 

DirectByteBuffer使用sun.misc.Unsafe#getByte(long)和sun.misc.Unsafe#putByte(long, byte)这两个方法来读写堆外内存空间的指定位置的字节数据。

//写入堆外内存
public ByteBuffer put(int i, byte x) {

    unsafe.putByte(ix(checkIndex(i)), ((x)));

    return this;

}

 
//读取堆外内存数据
public byte get(int i) {

    return ((unsafe.getByte(ix(checkIndex(i)))));

}

 

private long ix(int i) {

    return address + (i << 0);

}

 二、堆外内存回收

2.1 DirectByteBuffer及对应的堆外内存回收机制Cleaner

在DirectByteBuffer的构造函数的最后，我们看到了一行代码

// 使用Cleaner机制注册内存回收处理函数

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

这是使用Cleaner机制进行堆外内存回收。因为DirectByteBuffer申请的内存是在堆外，DirectByteBuffer本身支持保存了堆外内存的起始地址而已，所以DirectByteBuffer的内存占用是由堆内的DirectByteBuffer对象与堆外的对应内存空间共同构成。堆内的占用只是很小的一部分，这种对象被称为冰山对象。

堆内的DirectByteBuffer对象本身会被垃圾回收正常的处理，但是对外的内存就不会被GC回收了，所以需要一个机制，在DirectByteBuffer回收时，同时回收其堆外申请的内存。

Java中可选的特性有finalize函数，但是finalize机制是Java官方不推荐的，官方推荐的做法是使用虚引用来处理对象被回收时的后续处理工作，可以参考JDK源码阅读-Reference。同时Java提供了Cleaner类来简化这个实现，Cleaner是虚引用PhantomReference的子类，并通过自身的next和prev字段维护的一个双向链表。PhantomReference的作用在于跟踪垃圾回收过程，并不会对对象的垃圾回收过程造成任何的影响。

当DirectByteBuffer对象本身被GC时，DirectByteBuffer对象从pending状态 ——> enqueue状态时，会触发Cleaner的clean()，而Cleaner的clean()的方法会实现通过unsafe对堆外内存的释放。我们来看一下其回收处理函数是如何实现的：

2.1.1 Cleaner对象的创建

从代码 cleaner = Cleaner.create(this, new Deallocator(base, size, cap));可以看到创建对象需要两个参数

• DirectByteBuffer：当前创建的buffer对象
• Deallocator：是Runable接口的实现

Deallocator类是DirectByteBuffer内部类，代码如下：

private static class Deallocator implements Runnable {
        private static Unsafe unsafe = Unsafe.getUnsafe();
        private long address;
        private long size;
        private int capacity;

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

            assert (address != 0);

            this.address = address;

            this.size = size;

            this.capacity = capacity;

        }

        public void run() {
            if (this.address != 0L) {
                //通过unsafe释放内存
                unsafe.freeMemory(this.address);
                this.address = 0L;
                //更新内存参数统计
                Bits.unreserveMemory(this.size, this.capacity);
            }
        }
    }

 此线程实现很简单，就是将DirectByteBuffer对象分配时的内存地址释放和内存统计参数还原，什么时候回调此线程方法，我们继续往下看Cleaner对象的创建过程。

    //  Cleaner对象属性thunk
    private final Runnable thunk;

    //Object referent  DirectByteBuffer对象
    //Runnable thunk   Deallocator线程对象
    private Cleaner(Object referent, Runnable thunk) {
   
        //  继续调用父类PhantomReference初始化参数referent, dummyQueue)
        super(referent, dummyQueue);
        //  将实例化的Deallocator赋值给thunk
        this.thunk = thunk;
    }

继续调用Cleaner的父类PhantomReference实例化参数

    public PhantomReference(T referent, ReferenceQueue q) {
        super(referent, q);
    }

继续调用 PhantomReference父类Reference实例化参数，Reference代码不多，直接贴出来了。

public abstract class Reference {

    
    //被监控的对象：DirectByteBuffer对象
    private T referent;         /* Treated specially by GC */
    //队列ReferenceQueue对象
    volatile ReferenceQueue queue;

    /* When active:   NULL
     *     pending:   this
     *    Enqueued:   next reference in queue (or this if last)
     *    Inactive:   this
     */
    @SuppressWarnings("rawtypes")
    volatile Reference next;

    /* When active:   next element in a discovered reference list maintained by GC (or this if last)
     *     pending:   next element in the pending list (or null if last)
     *   otherwise:   NULL
     */
    //即将要pending的下一个Reference
    transient private Reference discovered;  /* used by VM */


    static private class Lock { }
    private static Lock lock = new Lock();

    //被Jvm赋值：DirectByteBuffer对象被GC回收后对应的Cleaner
    private static Reference