NIO源码解析-HeapBuffer与DirectBuffer

ByteBuffer buffer = ByteBuffer.allocate(10);
buffer.put("risk".getBytes());

// 直接对原HeapByteBuffer进行操作，会生成一个与原HeapByteBuffer一样的buffer，且只读
ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();

3. DirectByteBuffer

        字面意思是直接缓冲区。何为直接缓冲呢？

        实际就是堆外内存，该内存块不属于JVM的Heap堆，而是操作系统的其他内存块（本质上就是C语言用malloc进行分配所得到的内存块）。

        通过源码我们可以看到其与HeapByteBuffer分配时的不同

// ByteBuffer
public static ByteBuffer allocateDirect(int capacity) {
    return new DirectByteBuffer(capacity);
}

// DirectByteBuffer
DirectByteBuffer(int cap) {
    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 {
        // 通过unsafe来分配内存
        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来获取内存地址引用
        address = base;
    }
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
    att = null;
}

// Unsafe
public native long allocateMemory(long var1);

    Unsafe.allocateMemory是一个native方法，会调用到本操作系统相关的实现方法。（也就是上述所说的，C语言直接调用malloc创建的内存块）。而关于其put get等方法，都是通过Unsafe来控制的

// DirectByteBuffer
public ByteBuffer put(byte x) {
    unsafe.putByte(ix(nextPutIndex()), ((x)));
    return this;
}

public byte get() {
    return ((unsafe.getByte(ix(nextGetIndex()))));
}

4.DirectByteBuffer与HeapByteBuffer异同

    Q：既然我们已经有了HeapByteBuffer，那为什么还需要DirectByteBuffer呢？

    A：是由于操作系统没法直接访问JVM内存。

    细细想来，这个答案有明显的不合理处，操作系统作为底层设施，所有的进程都运行在其上，内存都由其来分配，怎么可能无法操作JVM的内存呢？

    理论上来说，操作系统是可以访问JVM内存空间的，但是由于JVM需要进行GC，如果当IO设备直接和JVM堆内存数据直接交互，此时JVM进行了GC操作，原来IO设备操作的字节被移动到其他区域，那IO设备便无法正确的获取到该字节数据。

    而DirectByteBuffer，是由操作系统直接分配的，位置不会变动，是可以与IO设置直接进行交互的。所以实际上当IO设备与HeapByteBuffer进行交互时，会先将HeapByteBuffer中的数据临时拷贝到DirectByteBuffer（临时创建的，使用后销毁），然后再从DirectByteBuffer拷贝到IO设置内存空间（一般就是内核空间）

    1）源码释疑

    我们可以通过源码来验证上面这段话的正确性（会涉及到后面Channel的知识点）

// 我们通过FileChannel打开一个文件，然后将HeapByteBuffer中的数据写入到该文件中
RandomAccessFile file = new RandomAccessFile(new File("C:\\Users\\lucky\\Desktop\\filetest.txt"), "rwd");
FileChannel channel = file.getChannel();

ByteBuffer buffer = ByteBuffer.allocate(10);
buffer.put((byte) 'h').put((byte) 'e').put((byte) 'l').put((byte) 'l').put((byte) 'o');

buffer.position(0);
// 通过channel将buffer中的数据写入
channel.write(buffer);

    观察FileChannel.write

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

                try {
                    this.begin();
                    var4 = this.threads.add();
                    if (!this.isOpen()) {
                        byte var12 = 0;
                        return var12;
                    } else {
                        do {
                            // 通过IOUtil来写入
                            var3 = IOUtil.write(this.fd, var1, -1L, this.nd);
                        } while(var3 == -3 && this.isOpen());

                        int var5 = IOStatus.normalize(var3);
                        return var5;
                    }
                } finally {
                    this.threads.remove(var4);
                    this.end(var3 > 0);

                    assert IOStatus.check(var3);

                }
            }
        }
    }

// IOUtil.java
static int write(FileDescriptor var0, ByteBuffer var1, long var2, NativeDispatcher var4) throws IOException {
        if (var1 instanceof DirectBuffer) {
            // 如果使用的就是DirectByteBuffer，则直接写入
            return writeFromNativeBuffer(var0, var1, var2, var4);
        } else {
            int var5 = var1.position();
            int var6 = var1.limit();

            assert var5