【操作系统】HeapByteBuffer和DirectByteBuffer的区别

DirectByteBuffer和HeapByteBuffer是Java NIO中ByteBuffer的两种实现方式。

HeapByteBuffer是在Java堆上分配的字节缓冲区，它使用数组来存储数据。HeapByteBuffer的优点是它具有良好的兼容性和可移植性，且在大多数情况下性能表现良好。它适用于大部分的应用场景，并且在内存管理方面具有更好的可控性和可调优性。

DirectByteBuffer是在直接内存中分配的字节缓冲区，它不是使用Java堆上的数组来存储数据，而是使用JNI（Java Native Interface）来直接操作本地内存。DirectByteBuffer的优点是它可以提供更高的IO性能，因为数据可以直接从内核缓冲区复制到DirectByteBuffer中，避免了数据的复制。它适用于处理大量的数据、网络数据传输、以及需要与本地库进行高效交互的场景。

堆内内存与堆外内存

堆内内存（Heap Memory）和堆外内存（Off-Heap Memory）是指在JAVA中两种不同的内存分配方式，其中的堆指的是JVM中的堆。

堆内内存：

• 堆内内存是指在Java堆中分配的内存。在Java中，对象的创建和销毁都是在堆内存中进行的。堆内内存由Java虚拟机（JVM）的垃圾回收机制进行管理，即通过垃圾回收器自动进行内存回收。

• 堆内内存具有自动内存管理的特性，程序员不需要手动释放内存。Java的堆内内存使用的是Java堆中的对象引用，通过引用计数和可达性分析等机制进行垃圾回收。

堆外内存：

• 堆外内存是指在Java堆之外分配的内存，也称为直接内存（Direct Memory）。

• 堆外内存通常由本地操作系统管理，不受JVM垃圾回收的控制。程序员需要手动释放这部分内存，一般通过Java NIO中的ByteBuffer的cleaner()方法或显式调用free()方法来释放。

• 堆外内存的分配和释放并不会受到Java堆内存的限制，可以提供更大的内存空间。

• 堆外内存适用于需要更高的IO性能、处理大量数据或需要与本地库进行高效交互的场景。在网络编程、数据库操作、图形处理等领域常常使用堆外内存。

需要注意的是，堆外内存的分配和释放需要谨慎操作，因为它不受Java堆内存的自动管理，容易导致内存泄漏和内存溢出等问题。因此，在使用堆外内存时，需要合理地管理内存的生命周期。

HeapByteBuffer

HeapByteBuffer主要用于在JVM堆内存中分配和操作字节。

HeapByteBuffer的使用如下：

package com.morris.io;import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.StandardCharsets;/*** HeapByteBuffer的使用*/
public class HeapByteBufferDemo {public static void main(String[] args) throws IOException {ByteBuffer byteBuffer = ByteBuffer.allocate(1024);byteBuffer.put("hello".getBytes(StandardCharsets.UTF_8));byteBuffer.flip();FileOutputStream fos = new FileOutputStream("HeapByteBufferDemo.txt");FileChannel channel = fos.getChannel();channel.write(byteBuffer);channel.close();fos.close();}
}

产生的系统调用如下：

openat(AT_FDCWD, "HeapByteBufferDemo.txt", O_WRONLY|O_CREAT|O_TRUNC, 0666) = 4
fstat(4, {st_mode=S_IFREG|0777, st_size=0, ...}) = 0
write(4, "hello", 5)                    = 5
close(4)

HeapByteBuffer的内部实现通过使用数组来存储数据，可以在HeapByteBuffer的构造方法中看到数组的创建：

HeapByteBuffer(int cap, int lim) {            // package-private// 创建了一个字节数组super(-1, 0, lim, cap, new byte[cap], 0);
}

DirectByteBuffer

DirectByteBuffer主要用于在操作系统的内存中分配和操作字节。与HeapByteBuffer不同，DirectByteBuffer直接在操作系统的内存中分配数据。

DirectByteBuffer的使用如下：

package com.morris.io;import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.StandardCharsets;/*** DirectByteBuffer的使用*/
public class DirectByteBufferDemo {public static void main(String[] args) throws IOException {System.in.read();ByteBuffer byteBuffer = ByteBuffer.allocateDirect(1024*128);byteBuffer.put("hello".getBytes(StandardCharsets.UTF_8));byteBuffer.flip();System.in.read();FileOutputStream fos = new FileOutputStream("DirectByteBufferDemo.txt");FileChannel channel = fos.getChannel();channel.write(byteBuffer);channel.close();fos.close();}
}

产生的系统调用如下：

mmap(NULL, 135168, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fdb8c000000
openat(AT_FDCWD, "DirectByteBufferDemo.txt", O_WRONLY|O_CREAT|O_TRUNC, 0666) = 4
fstat(4, {st_mode=S_IFREG|0777, st_size=0, ...}) = 0
write(4, "hello", 5)                    = 5
close(4)

我们在应用程序中申请了128KB（128*1024=131072B）的内存，底层会使用mmap系统调用在进程的堆内分配一块132KB的内存，这块内存是在进程的堆内，JVM的堆外

在上面的例子中，我们申请了128KB的内存，实际上分配一块132KB的内存，为什么会多分配4KB呢？我也没明白？

DirectByteBuffer的构造方法如下：

DirectByteBuffer(int cap) {                   // package-privatesuper(-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 boundaryaddress = base + ps - (base & (ps - 1));} else {address = base;}cleaner = Cleaner.create(this, new Deallocator(base, size, cap));att = null;
}

我们可以看到DirectByteBuffer底层是使用unsafe.allocateMemory来申请堆外内存，这是一个本地方法。

实际上我们自己也可以借助unsafe来申请堆外内存：

package com.morris.io;import sun.misc.Unsafe;import java.io.IOException;
import java.lang.reflect.Field;/*** 使用unsafe来申请内存*/
public class UnsafeAllocateMemoryDemo {public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException {Unsafe unsafe = getUnsafe();long address = unsafe.allocateMemory(128 * 1024);unsafe.freeMemory(address);}public static Unsafe getUnsafe() throws NoSuchFieldException, IllegalAccessException {Field field = Unsafe.class.getDeclaredField("theUnsafe");field.setAccessible(true);return (Unsafe) field.get(null);}
}

产生的系统调用如下：

mmap(NULL, 135168, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fe07801c000
munmap(0x7fe07801c000, 135168)          = 0

当使用mmap系统调用申请到堆外内存空间后，可以使用munmap系统调用来释放这块内存。

为什么要使用DirectByteBuffer？

从上面的例子可以看到DirectByteBuffer在使用的过程中会比HeapByteBuffer多一次系统调用，性能不如HeapByteBuffer，为什么性能差却还使用DirectByteBuffer呢？

看源码，这里以FileChannel实现类FileChannelImpl.read中为例：

sun.nio.ch.FileChannelImpl#write(java.nio.ByteBuffer)

public int write(ByteBuffer var1) throws IOException {this.ensureOpen();if (!this.writable) {throw new NonWritableChannelException();} else {synchronized(this.positionLock) {int var3 = 0;int var4 = -1;byte var5;try {this.begin();var4 = this.threads.add();if (this.isOpen()) {do {var3 = IOUtil.write(this.fd, var1, -1L, this.nd);} while(var3 == -3 && this.isOpen());int var12 = IOStatus.normalize(var3);return var12;}var5 = 0;} finally {this.threads.remove(var4);this.end(var3 > 0);assert IOStatus.check(var3);}return var5;}}
}

然后会调用IOUtil.write()：

static int write(FileDescriptor var0, ByteBuffer var1, long var2, NativeDispatcher var4) throws IOException {if (var1 instanceof DirectBuffer) {return writeFromNativeBuffer(var0, var1, var2, var4);} else {int var5 = var1.position();int var6 = var1.limit();assert var5 <= var6;int var7 = var5 <= var6 ? var6 - var5 : 0;ByteBuffer var8 = Util.getTemporaryDirectBuffer(var7);int var10;try {var8.put(var1);var8.flip();var1.position(var5);int var9 = writeFromNativeBuffer(var0, var8, var2, var4);if (var9 > 0) {var1.position(var5 + var9);}var10 = var9;} finally {Util.offerFirstTemporaryDirectBuffer(var8);}return var10;}
}

当向FileChannel中写数据，数据来源是DirectByteBuffer时，可以直接将DirectByteBuffer中的数据写入到文件中。

当向FileChannel中写数据，数据来源是HeapByteBuffer时，需要先将数据从HeapByteBuffer写入到一个临时的DirectByteBuffer中，再将临时DirectByteBuffer中的数据写入到文件中。

所以，当java程序数据需要频繁与本地io（本地磁盘、socket传输数据时），使用HeapByteBuffer读取时要多复制一次数据（即从DirectByteBuffer再复制到heapByteBuffer）。再加上写数据到本地时，又要再从HeapByteBuffer复制到另一个DirectByteBuffer，多了两次复制。

HeapByteBuffer底层其实是java的字节数组，而java字节数组是一个java对象，对象的内存是由jvm的堆进行管理的，那么不可避免的是GC时年轻代的eden、suvivor到老年代的各种复制以及回收。当字节数组比较小的时候还好说，如果是大对象，那么对于jvm的GC来说是一个很大的负担。而使用DirectByteBuffer，则是把字节数组交给操作系统管理（堆外内存），就可以极大的减少jvm的负担了。

DirectByteBuffer和HeapByteBuffer的使用场景

什么情况下使用DirectByteBuffer?

• 频繁的native IO，即java程序与本地磁盘、socket传输数据。

• 不需要经常创建和销毁DirectByteBuffer对象，有系统调用代价大，可以使用池复用DirectByteBuffer

• DirectByteBuffer不会占用堆内存。也就是不会受到堆大小限制，只在DirectByteBuffer对象被回收后才会释放该缓冲区。

• 大文件造成大对象，对GC负担比较重的情况

什么情况下使用HeapByteBuffer?其实除了上述的DirectByteBuffer使用场景之外的，基本可以用HeapByteBuffer。

• 数据仅在java程序中流转传输，不与本地进行IO，例如Netty的责任链中传递对象可以使用HeapByteBuffer

• 容量低，对GC负担低。快速回收