NIO DirectBuffer

介绍

​ 最近在工作中使用到了DirectBuffer来进行临时数据的存放，由于使用的是堆外内存，省去了数据到内核的拷贝，因此效率比用ByteBuffer要高不少。之前看过许多介绍DirectBuffer的文章，在这里从源码的角度上来看一下DirectBuffer的原理。

用户态和内核态

​ Intel的 X86架构下，为了实现外部应用程序与操作系统运行时的隔离，分为了Ring0-Ring3四种级别的运行模式。Linux/Unix只使用了Ring0和Ring3两个级别。Ring0被称为内核态，Ring3被称为用户态。普通的应用程序只能运行在Ring3，并且不能访问Ring0的地址空间。操作系统运行在Ring0，并提供系统调用供用户态的程序使用。如果用户态的程序的某一个操作需要内核态来协助完成(例如读取磁盘上的某一段数据)，那么用户态的程序就会通过系统调用来调用内核态的接口，请求操作系统来完成某种操作。

ByteBuffer

在Java的NIO中，我们一般采用ByteBuffer缓冲区来传输数据，一般情况下我们创建Buffer对象是通过ByteBuffer的两个静态方法：

ByteBuffer.allocate(int capacity);
ByteBuffer.wrap(byte[] array);

查看JDK的NIO的源代码关于这两个部分：

public static ByteBuffer allocate(int capacity) {
    if (capacity < 0)
        throw new IllegalArgumentException();
    return new HeapByteBuffer(capacity, capacity);
}

public static ByteBuffer wrap(byte[] array) {
   return wrap(array, 0, array.length);
}

public static ByteBuffer wrap(byte[] array, int offset, int length) {
    try {
        return new HeapByteBuffer(array, offset, length);
    } catch (IllegalArgumentException x) {
        throw new IndexOutOfBoundsException();
    }
}

我们可以很清楚的发现，这两个方法都是实例化HeapByteBuffer来创建的ByteBuffer对象，也就是heap buffer. 其实除了heap buffer以外还有一种buffer，叫做direct buffer。

DirectBuffer的创建

使用下面一行代码就可以创建一个1024字节的DirectBuffer：

ByteBuffer.allocateDirect(1024);

该方法调用的是

new DirectByteBuffer(int cap);

下面我们来看一下这行代码背后的逻辑:

DirectByteBuffer(int cap) {

    super(-1, 0, cap, cap);
    // 是否页对齐
    boolean pa = VM.isDirectMemoryPageAligned();
    // 获取pageSize大小
    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;
    }
    // 生成Cleaner
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
    att = null;

}

DirectBuffer的构造方法主要做以下三个事情：

1、根据页对齐和pageSize来确定本次的要分配内存实际大小 2、实际分配内存，并且记录分配的内存大小 3、声明一个Cleaner对象用于清理该DirectBuffer内存

需要注意的是DirectBuffer的创建是比较耗时的，所以在一些高性能的中间件或者应用下一般会做一个对象池，用于重复利用DirectBuffer。

DirectBuffer的使用

​ 查看DirectBuffer类的方法声明，对于DirectBuffer的使用主要有两类方法，putXXX和getXXX。

putXXX方法(以putInt为例)：

public ByteBuffer putInt(int x) {
    putInt(ix(nextPutIndex((1 << 2))), x);
    return this;
}

private ByteBuffer putInt(long a, int x) {
    if (unaligned) {
        int y = (x);
        unsafe.putInt(a, (nativeByteOrder ? y : Bits.swap(y)));
    } else {
        Bits.putInt(a, x, bigEndian);
    }
    return this;
}

putInt方法会根据是否是内存对齐分别调用unsafe.putInt或者Bits.putInt来把数据放到直接内存中。Bits.putInt实际上会根据是大端或者是小端来区分如何把数据放到直接内存中，放的方式同样是调用unsage.putInt。

getXXX方法(以getInt为例)：

public int getInt() {
    return getInt(ix(nextGetIndex((1 << 2))));
}

private int getInt(long a) {
    if (unaligned) {
        int x = unsafe.getInt(a);
        return (nativeByteOrder ? x : Bits.swap(x));
    }
    return Bits.getInt(a, bigEndian);
}

首先判断是否是页对齐，如果不是页对齐，那么直接通过unsafe.getInt来获取数据；如果是页对齐，那么通过Bits.getInt方法来获取数据。Bits.getInt同样是根据大端还是小端，调用unsafe.getInt来获取数据。

DirectBuffer内存回收

​ DirectBuffer内存回收主要有两种方式，一种是通过System.gc来回收，另一种是通过构造方法里创建的Cleaner对象来回收。

System.gc回收

在DirectBuffer的构造方法中，用到了Bits.reserveMemory这个方法，该方法如下

    static void reserveMemory(long size, int cap) {

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

reserveMemory方法首先尝试分配内存，如果分配成功的话，那么就直接退出。如果分配失败那么就通过调用tryHandlePendingReference来尝试清理堆外内存(最终调用的是Cleaner的clean方法，其实就是unsafe.freeMemory然后释放内存)，清理完内存之后再尝试分配内存。如果还是失败，调用System.gc()来触发一次FullGC进行回收(前提是没有加-XX:-+DisableExplicitGC参数)。GC完之后再进行内存分配，失败的话就会进行sleep，然后再进行尝试。每次sleep的时间是逐步增加的，规律是1, 2, 4, 8, 16, 32, 64, 128, 256 (total 511 ms ~ 0.5 s)。如果最终还没有可分配的内存，那么就会抛出OOM异常。

为什么是通过调用tryHandlePendingReference来回收内存呢？答案是JVM在判断内存不可达之后会把需要GC的不可达对象放在一个PendingList中，然后应用程序就可以看到这些对象。通过调用tryHandlePendingReference来访问这些不可达对象。如果不可达对象是Cleaner类型，也就是说关联了堆外的DirectBuffer，那么该DirectBuffer就可以被回收了，通过调用Cleaner的clean方法来回收这部分堆外内存。

这个逻辑就是进行堆外内存分配时触发的回收内存逻辑，也就是说在分配的时候如果遇到堆外内存不足，可能会触发FullGC，然后尝试进行分配。这也是为什么在一些用到堆外内存的应用中不建议加上-XX:-+DisableExplicitGC参数。

Cleaner对象回收

另个触发堆外内存回收的时机是通过Cleaner对象的clean方法进行回收。在每次新建一个DirectBuffer对象的时候，会同时创建一个Cleaner对象，同一个进程创建的所有的DirectBuffer对象跟Cleaner对象的个数是一样的，并且所有的Cleaner对象会组成一个链表，前后相连。

public static Cleaner create(Object ob, Runnable thunk) {
    if (thunk == null)
        return null;
    return add(new Cleaner(ob, thunk));
}

Cleaner对象的clean方法执行时机是JVM在判断该Cleaner对象关联的DirectBuffer已经不被任何对象引用了(也就是经过可达性分析判定为不可达的时候)。此时Cleaner对象会被JVM挂到PendingList上。然后有一个固定的线程扫描这个List，如果遇到Cleaner对象，那么就执行clean方法。

DirectBuffer在一些高性能的中间件上使用还是相当广泛的。正确的使用可以提升程序的性能，降低GC的频率。