一文搞懂ByteBuffer使用与原理

Dear 丶 2023-09-25 21:50 76阅读 0赞

## 前言 ##

已知**NIO**中有三大组件：**Channel**，**Buffer**和**Selector**。那么**Buffer**的作用就是提供一个缓冲区，用于用户程序和**Channel**之间进行数据读写，也就是用户程序中可以使用**Buffer**向**Channel**写入数据，也可以使用**Buffer**从**Channel**读取数据。

**ByteBuffer**是**Buffer**子类，是字节缓冲区，特点如下所示。

1.  **大小不可变**。一旦创建，无法改变其容量大小，无法扩容或者缩容；
2.  **读写灵活**。内部通过指针移动来实现灵活读写；
3.  支持**堆上**内存分配和**直接**内存分配。

本文将对**ByteBuffer**的相关概念，常用**API**以及使用案例进行分析。全文约1万字，知识点脑图如下。

![format_png][]

## 正文 ##

### 一. Buffer ###

在**NIO**中，八大基础数据类型中除了**boolean**外，都有相应的**Buffer**的实现，类图如下所示。

![format_png 1][]

**Buffer**类对各种基础数据类型的缓冲区做了顶层抽象，所以要了解**ByteBuffer**，首先应该学习**Buffer**类。

1. Buffer的属性

所有缓冲区结构都有如下属性。

<table> 
 <thead> 
 <tr> 
 <th>属性</th> 
 <th>说明</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>int position</td> 
 <td>位置索引。代表下一次将要操作的元素的位置，默认初始为0，位置索引最小为0，最大为limit</td> 
 </tr> 
 <tr> 
 <td>int limit</td> 
 <td>限制索引。限制索引及之后的索引位置上的元素都不能操作，限制索引最小为0，最大为capacity</td> 
 </tr> 
 <tr> 
 <td>int capacity</td> 
 <td>容量。缓冲区的最大元素个数，创建缓冲区时指定，最小为0，不能改变</td> 
 </tr> 
 </tbody> 
</table>

三者之间的大小关系应该是：**0 <= position <= limit <= capacity**，图示如下。

![format_png 2][]

除此之外，还有一个属性叫做**mark**，如下所示。

<table> 
 <thead> 
 <tr> 
 <th>属性</th> 
 <th>说明</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>int mark</td> 
 <td>标记索引。mark会标记一个索引，在Buffer#reset调用时，将position重置为mark。mark不是必须的，但是当定义mark后，其最小为0，最大为position</td> 
 </tr> 
 </tbody> 
</table>

关于**mark**还有如下两点说明。

1.  **position**或**limit**一旦小于**mark**则**mark**会被丢弃；
2.  没有定义**mark**时如果调用了**Buffer\#reset**则会抛出**InvalidMarkException**。

2. Buffer的读模式

**Buffer**有两种模式，读模式和写模式，在读模式下，可以读取缓冲区中的数据。那么对于一个缓冲区，要读取数据时，分为两步。

1.  拿到**position**位置索引；
2.  取**position**位置的数据。

那么**Buffer**提供了**nextGetIndex()** 方法和**nextGetIndex(int nb)** 方法来获取**position**，先看一下**nextGetIndex()** 方法的实现。

final int nextGetIndex() {
        // limit位置是不可操作的
        if (position >= limit) {
            throw new BufferUnderflowException();
        }
        // 返回当前position
        // 然后position后移一个位置
        return position++;
    }
    复制代码

**nextGetIndex()** 方法首先校验一下**position**是否大于等于**limit**，因为**limit**及之后的位置都是不可操作的，所以只要满足**position**大于等于**limit**则抛出异常，然后返回当前的**position**（也就是当前可操作的位置），最后**position**后移一位。

而**nextGetIndex(int nb)** 方法，则是用于**Buffer**的子类**ByteBuffer**使用，因为**ByteBuffer**的一个元素就是一个字节，而如果想要通过**ByteBuffer**获取一个整形数据，那么此时就需要连续读取四个字节。**nextGetIndex(int nb)** 方法如下所示。

final int nextGetIndex(int nb) {
 // 判断一下剩余可操作元素是否够本次获取
 if (limit - position < nb) {
 throw new BufferUnderflowException();
 }
 // 暂存当前position
 int p = position;
 // 然后position后移nb个位置
 position += nb;
 // 返回暂存的position
 return p;
 }
 复制代码

拿到**position**后，实际的读取数据，由**Buffer**的子类来实现。

3. Buffer的写模式

有读就有写，在**Buffer**的写模式下，写入数据也是分为两步。

1.  拿到**position**位置索引；
2.  写入数据到**position**位置。

写模式下，**Buffer**同样为获取**position**提供了两个方法，如下所示。

final int nextPutIndex() {
 // limit位置是不可操作的
 if (position >= limit) {
 throw new BufferOverflowException();
 }
 // 返回当前position
 // 然后position后移一个位置
 return position++;
 }
 
 final int nextPutIndex(int nb) {
 // 判断一下剩余可操作元素是否够本次写入
 if (limit - position < nb) {
 throw new BufferOverflowException();
 }
 // 暂存当前position
 int p = position;
 // 然后position后移nb个位置
 position += nb;
 // 返回暂存的position
 return p;
 }
 复制代码

同样，拿到**position**后，实际的写入数据，由**Buffer**的子类来实现。

4. Buffer读写模式切换

**Buffer**提供了读模式和写模式，同一时间**Buffer**只能在同一模式下工作，相应的，**Buffer**提供了对应的方法来做读写模式切换。

首先是读模式切换到写模式，先看如下示意图。

![format_png 3][]

上图中的情况是缓冲区中的数据已经全部被读完，那么此时如果要切换到写模式，对应的方法是**clear()** 方法，如下所示。

public final Buffer clear() {
        // 重置position为0
        position = 0;
        // 设置limit为capacity
        limit = capacity;
        // 重置mark为-1
        mark = -1;
        return this;
    }
    复制代码

注意，虽然方法名叫做**clear()**，但是实际缓冲区中的数据并没有被清除，而只是将位置索引**position**，限制索引**limit**进行了重置，同时清除了标记状态（也就是将**mark**设置为-1）。切换到写模式后，缓冲区示意图如下所示。

![format_png 4][]

然后是写模式切换到读模式，先看如下示意图。

![format_png 5][]

数据已经写入完毕了，此时如果要切换到读模式，对应的方法是**flip()**，如下所示。

public final Buffer flip() {
        // 因为position位置还没写入数据
        // 所以将position位置设置为limit
        limit = position;
        // 重置position为0
        position = 0;
        // 重置mark为-1
        mark = -1;
        return this;
    }
    复制代码

因为**position**永远代表下一个可操作的位置，那么在写模式下，**position**代表下一个写入的位置，那么其实就还没有数据写入，所以调用**flip()** 方法后，首先将**position**位置设置为**limit**，表示数据最多读取到**limit**的上一个位置，然后重置**position**和**mark**。切换到读模式后，缓冲区示意图如下所示。

![format_png 6][]

5. Buffer的rewind操作

在使用**Buffer**时，可以针对已经操作的区域进行重操作，假设缓冲区示意图如下。

![format_png 7][]

再看一下**rewind()** 方法的实现，如下所示。

public final Buffer rewind() {
        // 重置position为0
        position = 0;
        // 清除mark
        mark = -1;
        return this;
    }
    复制代码

主要就是将位置索引**position**重置为0，这样就能重新操作已经操作过的位置了，同时如果启用了**mark**，那么还会清除**mark**，也就是重置**mark**为-1。**rewind()** 方法调用后的缓冲区示意图如下所示。

![format_png 8][]

6. Buffer的reset操作

在使用**Buffer**时，可以启用**mark**来标记一个已经操作过的位置，假设缓冲区示意图如下。

![format_png 9][]

再看一下**reset()** 方法的实现，如下所示。

public final Buffer reset() {
 int m = mark;
 // 只要启用mark那么mark就不能为负数
 if (m < 0) {
 throw new InvalidMarkException();
 }
 // 将position重置为mark
 position = m;
 return this;
 }
 复制代码

在没有启用**mark**时，**mark**为-1，只要启用了**mark**，那么**mark**就不能为负数。在**reset()** 中主要就是将位置索引**position**重新设置到**mark**标记的位置，以实现对**mark**标记的位置及之后的位置进行重新操作。**reset()** 方法调用后的缓冲区示意图如下所示。

![format_png 10][]

### 二. ByteBuffer ###

在上一节主要对**Buffer**进行了一个说明，那么本节会在上一节的基础上，对**ByteBuffer**及其实现进行学习。

1. ByteBuffer的属性

**ByteBuffer**相较于**Buffer**，多了如下三个属性。

<table> 
 <thead> 
 <tr> 
 <th>属性</th> 
 <th>说明</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>byte[] hb</td> 
 <td>字节数组。仅HeapByteBuffer会使用到，HeapByteBuffer的数据存储在hb中</td> 
 </tr> 
 <tr> 
 <td>int offset</td> 
 <td>偏移量。仅HeapByteBuffer会使用到，后面会详细说明</td> 
 </tr> 
 <tr> 
 <td>isReadOnly</td> 
 <td>是否只读。仅HeapByteBuffer会使用到，后面会详细说明</td> 
 </tr> 
 </tbody> 
</table>

**NIO**中为**ByteBuffer**分配内存时，可以有两种方式。

1.  在堆上分配内存，此时得到**HeapByteBuffer**；
2.  在直接内存中分配内存，此时得到**DirectByteBuffer**。

类图如下所示。

![format_png 11][]

因为**DirectByteBuffer**是分配在直接内存中，肯定无法像**HeapByteBuffer**一样将数据存储在字节数组，所以**DirectByteBuffer**会通过一个**address**字段来标识数据所在直接内存的开始地址。**address**字段定义在**Buffer**中，如下所示。

long address;
    复制代码

2. ByteBuffer的创建

**ByteBuffer**提供了如下四个方法用于创建**ByteBuffer**，如下所示。

<table> 
 <thead> 
 <tr> 
 <th>方法</th> 
 <th>说明</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>allocate(int capacity)</td> 
 <td>在堆上分配一个新的字节缓冲区。说明如下： 1. 创建出来后，position为0，并且limit会取值为capacity； 2. 创建出来的实际为HeapByteBuffer，其内部使用一个字节数组hb存储元素； 3. 初始时hb中所有元素为0</td> 
 </tr> 
 <tr> 
 <td>allocateDirect(int capacity)</td> 
 <td>在直接内存中分配一个新的字节缓冲区。说明如下： 1. 创建出来后，position为0，并且limit会取值为capacity； 2. 创建出来的实际为DirectByteBuffer，是基于操作系统创建的内存区域作为缓冲区； 3. 初始时所有元素为0</td> 
 </tr> 
 <tr> 
 <td>wrap(byte[] array)</td> 
 <td>将字节数组包装到字节缓冲区中。说明如下： 1. 创建出来的是HeapByteBuffer，其内部的hb字节数组就会使用传入的array； 2. 改变HeapByteBuffer会影响array，改变array会影响HeapByteBuffer； 3. 得到的HeapByteBuffer的limit和capacity均取值为array.length； 4. position此时都为0</td> 
 </tr> 
 <tr> 
 <td>wrap(byte[] array, int off, int length)</td> 
 <td>将字节数组包装到字节缓冲区，说明如下。 1. 创建出来的是HeapByteBuffer，其内部的hb字节数组就会使用传入的array； 2. 改变HeapByteBuffer会影响array，改变array会影响HeapByteBuffer； 3. capacity取值为array.length； 4. limit取值为off + length； 5. position取值为off</td> 
 </tr> 
 </tbody> 
</table>

下面结合源码，分析一下上述四种创建方式。

首先是**allocate(int capacity)**，如下所示。

public static ByteBuffer allocate(int capacity) {
 if (capacity < 0) {
 throw new IllegalArgumentException();
 }
 // 直接创建HeapByteBuffer
 // HeapByteBuffer(int cap, int lim)
 return new HeapByteBuffer(capacity, capacity);
 }
 复制代码

然后是**allocateDirect(int capacity)**，如下所示。

public static ByteBuffer allocateDirect(int capacity) {
        return new DirectByteBuffer(capacity);
    }
    
    DirectByteBuffer(int cap) {
        // MappedByteBuffer(int mark, int pos, int lim, 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 {
            // 分配堆外内存
            base = unsafe.allocateMemory(size);
        } catch (OutOfMemoryError x) {
            Bits.unreserveMemory(size, cap);
            throw x;
        }
        unsafe.setMemory(base, size, (byte) 0);
        // 计算堆外内存起始地址
        if (pa && (base % ps != 0)) {
            address = base + ps - (base & (ps - 1));
        } else {
            address = base;
        }
        // 通过虚引用的手段来监视DirectByteBuffer是否被垃圾回收
        // 从而可以及时的释放堆外内存空间
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
        att = null;
    }
    复制代码

然后是**wrap(byte\[\] array)**，如下所示。

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

其实**wrap(byte\[\] array)** 方法就是调用的**wrap(byte\[\] array, int off, int length)**，下面直接看**wrap(byte\[\] array, int off, int length)** 方法的实现。

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

这里先简单说明一下上述方法中的**off**和**length**这两个参数的含义。

1.  **off**就是表示字节数组封装到字节缓冲区后，**position**的位置，所以有**position = off**；
2.  **length**简单理解就是用于计算**limit**，即**limit = position + length**。其实**length**是理解为字节数组封装到字节缓冲区后，要使用的字节数组的长度。

下面给出一张**wrap(byte\[\] array, int off, int length)** 方法的作用示意图。

![format_png 12][]

最后说明一点，无论是**wrap(byte\[\] array)** 还是**wrap(byte\[\] array, int off, int length)** 方法，均构造的是**HeapByteBuffer**。

3. ByteBuffer的slice操作

在**ByteBuffer**中定义了一个抽象方法叫做**slice()**，用于在已有的**ByteBuffer**上得到一个新的**ByteBuffer**，两个**ByteBuffer**的**position**，**limit**，**capacity**和**mark**都是独立的，但是底层存储数据的内存区域是一样的，那么相应的，对其中任何一个**ByteBuffer**做更改，会影响到另外一个**ByteBuffer**。

下面先看一下**HeapByteBuffer**对**slice()** 方法的实现。

public ByteBuffer slice() {
        return new HeapByteBuffer(hb, -1, 0, this.remaining(), this.remaining(), this.position() + offset);
    }
    
    public final int remaining() {
        return limit - position;
    }
    
    protected HeapByteBuffer(byte[] buf, int mark, int pos, int lim, int cap, int off) {
        super(mark, pos, lim, cap, buf, off);
    }
    
    ByteBuffer(int mark, int pos, int lim, int cap,
               byte[] hb, int offset) {
        super(mark, pos, lim, cap);
        this.hb = hb;
        this.offset = offset;
    }
    复制代码

新的**HeapByteBuffer**的**mark**重置为了-1，**position**重置为了0，**limit**等于**capacity**等于老的**HeapByteBuffer**的未操作数据的长度（老的**limit - posittion**）。

此外，两个**HeapByteBuffer**存储数据的字节数组**hb**是同一个，且新的**HeapByteBuffer**的**offset**等于老的**HeapByteBuffer**的**position**，什么意思呢，先看下面这张图。

![format_png 13][]

意思就是，在新的**HeapByteBuffer**中，操作**position**位置的元素，实际是在操作**hb\[position + offset\]** 位置的元素，那么这里也就解释了**ByteBuffer**中**offset**属性的作用，就是表示要操作字节数组时的索引偏移量。

有了上面对**HeapByteBuffer**的理解，那么现在再看**DirectByteBuffer**就显得很简单了，**DirectByteBuffer**对**slice()** 方法的实现如下所示。

public ByteBuffer slice() {
 int pos = this.position();
 int lim = this.limit();
 assert (pos <= lim);
 int rem = (pos <= lim ? lim - pos : 0);
 int off = (pos << 0);
 assert (off >= 0);
 return new DirectByteBuffer(this, -1, 0, rem, rem, off);
 }
 
 DirectByteBuffer(DirectBuffer db,
 int mark, int pos, int lim, int cap,
 int off) {
 super(mark, pos, lim, cap);
 address = db.address() + off;
 cleaner = null;
 att = db;
 }
 复制代码

**DirectByteBuffer**对**slice()** 方法的实现和**HeapByteBuffer**差不多，只不过在**HeapByteBuffer**中是对字节数组索引有偏移，而在**DirectByteBuffer**中是对堆外内存地址有偏移，同时偏移量都是老的**ByteBuffer**的**position**的值。

最后针对**slice()** 方法，有一点小说明，在**DirectByteBuffer**的**att**中有这么一段注释。

> **If this buffer is a view of another buffer then ...**

这里提到了**view**，翻译过来叫做视图，其实调用**ByteBuffer**的**slice()** 方法，可以想象成就是为原字节缓冲区创建了一个视图，这个视图和原字节缓冲区共享同一片内存区域，但是有新的一套**mark**，**position**，**limit**和**capacity**。

4. ByteBuffer的asReadOnlyBuffer操作

**ByteBuffer**定义了一个抽象方法叫做**asReadOnlyBuffer()**，会在当前**ByteBuffer**基础上创建一个新的**ByteBuffer**，创建出来的**ByteBuffer**能看见老**ByteBuffer**的数据（共享同一块内存），但只能读不能写（只读的），同时两个**ByteBuffer**的**position**，**limit**，**capacity**和**mark**是独立的。

先看一下**HeapByteBuffer**对**asReadOnlyBuffer()** 方法的实现，如下所示。

public ByteBuffer asReadOnlyBuffer() {
        return new HeapByteBufferR(hb,
                this.markValue(),
                this.position(),
                this.limit(),
                this.capacity(),
                offset);
    }
    
    protected HeapByteBufferR(byte[] buf,
                              int mark, int pos, int lim, int cap,
                              int off) {
        super(buf, mark, pos, lim, cap, off);
        this.isReadOnly = true;
    }
    复制代码

也就是会**new**一个**HeapByteBufferR**出来，并且会指定其**isReadOnly**字段为**true**，表示只读。**HeapByteBufferR**继承于**HeapByteBuffer**，表示只读**HeapByteBuffer**，**HeapByteBufferR**重写了**HeapByteBuffer**的所有写相关方法，并且在这些写相关方法中抛出**ReadOnlyBufferException**异常，下面是部分写方法的示例。

public ByteBuffer put(int i, byte x) {
        throw new ReadOnlyBufferException();
    }
    
    public ByteBuffer put(byte x) {
        throw new ReadOnlyBufferException();
    }
    复制代码

再看一下**DirectByteBuffer**对**asReadOnlyBuffer()** 方法的实现，如下所示。

public ByteBuffer asReadOnlyBuffer() {
        return new DirectByteBufferR(this,
                this.markValue(),
                this.position(),
                this.limit(),
                this.capacity(),
                0);
    }
    
    DirectByteBufferR(DirectBuffer db,
                      int mark, int pos, int lim, int cap,
                      int off) {
        super(db, mark, pos, lim, cap, off);
    }
    复制代码

也是会**new**一个只读的**DirectByteBufferR**，**DirectByteBufferR**继承于**DirectByteBuffer**并重写了所有写相关方法，并且在这些写相关方法中抛出**ReadOnlyBufferException**异常。

5. ByteBuffer的写操作

**ByteBuffer**中定义了大量写操作相关的抽象方法，如下图所示。

![format_png 14][]

总体可以进行如下归类。

![format_png 15][]

下面将对上述部分写方法结合源码进行说明。

Ⅰ. put(byte)

首先是最简单的**put(byte)** 方法，作用是往字节缓冲区的**position**位置写入一个字节，先看一下**HeapByteBuffer**对其的实现，如下所示。

public ByteBuffer put(byte x) {
        hb[ix(nextPutIndex())] = x;
        return this;
    }
    
    protected int ix(int i) {
        return i + offset;
    }
    
    // Buffer#nextPutIndex()
    final int nextPutIndex() {
        if (position >= limit) {
            throw new BufferOverflowException();
        }
        return position++;
    }
    复制代码

再看一下**DirectByteBuffer**对**put(byte)** 方法的实现，如下所示。

public ByteBuffer put(byte x) {
 unsafe.putByte(ix(nextPutIndex()), ((x)));
 return this;
 }
 
 private long ix(int i) {
 return address + ((long)i << 0);
 }
 
 // Buffer#nextPutIndex()
 final int nextPutIndex() {
 if (position >= limit) {
 throw new BufferOverflowException();
 }
 return position++;
 }
 复制代码

都是会调用到**Buffer\#nextPutIndex()** 方法来拿到当前的**position**，区别是**HeapByteBuffer**是将字节写入到堆上的数组，而**DirectByteBuffer**是写在直接内存中。

Ⅱ. put(int, byte)

**put(int, byte)** 方法能够在指定位置写入一个字节，注意该方法写入字节不会改变**position**。

**HeapByteBuffer**对其实现如下所示。

public ByteBuffer put(int i, byte x) {
 hb[ix(checkIndex(i))] = x;
 return this;
 }
 
 protected int ix(int i) {
 return i + offset;
 }
 
 // Buffer#checkIndex(int)
 final int checkIndex(int i) {
 if ((i < 0) || (i >= limit)) {
 throw new IndexOutOfBoundsException();
 }
 return i;
 }
 复制代码

**DirectByteBuffer**对**put(int, byte)** 方法的实现如下所示。

public ByteBuffer put(int i, byte x) {
 unsafe.putByte(ix(checkIndex(i)), ((x)));
 return this;
 }
 
 private long ix(int i) {
 return address + ((long) i << 0);
 }
 
 // Buffer#checkIndex(int)
 final int checkIndex(int i) {
 if ((i < 0) || (i >= limit)) {
 throw new IndexOutOfBoundsException();
 }
 return i;
 }
 复制代码

Ⅲ. put(byte\[\], int, int)

**put(byte\[\], int, int)** 方法是批量的将字节数组中指定的字节写到**ByteBuffer**。

**put(byte\[\], int, int)** 方法并不是抽象方法，在**ByteBuffer**中定义了其实现，但同时**HeapByteBuffer**和**DirectByteBuffer**也都对其进行了重写。下面分别看一下其实现。

**ByteBuffer\#put(byte\[\], int, int)** 实现如下所示。

public ByteBuffer put(byte[] src, int offset, int length) {
 checkBounds(offset, length, src.length);
 if (length > remaining()) {
 throw new BufferOverflowException();
 }
 int end = offset + length;
 // 从src的offset索引开始依次将后续的length个字节写到ByteBuffer中
 for (int i = offset; i < end; i++) {
 this.put(src[i]);
 }
 return this;
 }
 复制代码

**ByteBuffer**对**put(byte\[\], int, int)** 方法的实现是循环遍历字节数组中每一个需要写入的字节，然后调用**put(byte)** 方法完成写入，其中**offset**表示从字节数组的哪一个字节开始写，**length**表示从**offset**开始往后的多少个字节需要写入。

由于**ByteBuffer**对**put(byte\[\], int, int)** 方法的实现的写入效率不高，所以**HeapByteBuffer**和**DirectByteBuffer**都有自己的实现，先看一下**HeapByteBuffer**对**put(byte\[\], int, int)** 方法的实现，如下所示。

public ByteBuffer put(byte[] src, int offset, int length) {
        checkBounds(offset, length, src.length);
        if (length > remaining()) {
            throw new BufferOverflowException();
        }
        // 使用了native的拷贝方法来实现更高效的写入
        System.arraycopy(src, offset, hb, ix(position()), length);
        position(position() + length);
        return this;
    }
    复制代码

由于**HeapByteBuffer**存储字节是存储到字节数组中，所以直接使用**native**的**arraycopy()** 方法来完成字节数组的拷贝是更为高效的手段。

再看一下**DirectByteBuffer**对**put(byte\[\], int, int)** 方法的实现，如下所示。

public ByteBuffer put(byte[] src, int offset, int length) {
 // 写入字节数大于6时使用native方法来批量写入才更高效
 if (((long) length << 0) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
 checkBounds(offset, length, src.length);
 int pos = position();
 int lim = limit();
 assert (pos <= lim);
 int rem = (pos <= lim ? lim - pos : 0);
 if (length > rem) {
 throw new BufferOverflowException();
 }
 // 这里最终会调用到native方法Unsafe#copyMemory来批量写入
 Bits.copyFromArray(src, arrayBaseOffset,
 (long) offset << 0,
 ix(pos),
 (long) length << 0);
 // 更新position
 position(pos + length);
 } else {
 // 写入字节数小于等于6则遍历每个字节并依次写入会更高效
 super.put(src, offset, length);
 }
 return this;
 }
 复制代码

在**DirectByteBuffer**的实现中，并没有直接调用到**native**方法来批量操作直接内存，而是先做了判断：如果本次批量写入的字节数大于**JNI\_COPY\_FROM\_ARRAY\_THRESHOLD**（默认是**6**），才调用**native**方法**Unsafe\#copyMemory**来完成字节在直接内存中的批量写入，否则就还是一个字节一个字节的写入。**DirectByteBuffer**的做法主要还是考虑到**native**方法的调用的一个开销，比如就写入一个字节，那肯定是没有必要调用**native**方法的。

Ⅳ. put(byte\[\])

**put(byte\[\])** 方法的作用是将一个字节数组的内容全部写入到**ByteBuffer**，该方法是一个**final**方法，所以这里看一下**ByteBuffer**中该方法的实现，如下所示。

public final ByteBuffer put(byte[] src) {
        return put(src, 0, src.length);
    }
    复制代码

其实就是调用到**put(byte\[\], int, int)** 方法来完成批量写入。

Ⅴ. put(ByteBuffer)

**put(ByteBuffer)** 方法用于将一个**ByteBuffer**中所有未操作的字节批量写入当前**ByteBuffer**。**ByteBuffer**，**HeapByteBuffer**和**DirectByteBuffer**都有相应的实现，下面分别看一下。

**ByteBuffer\#put(ByteBuffer)** 思路还是一个字节一个字节的写入，实现如下。

public ByteBuffer put(ByteBuffer src) {
 if (src == this) {
 throw new IllegalArgumentException();
 }
 if (isReadOnly()) {
 throw new ReadOnlyBufferException();
 }
 // 计算limit - position
 int n = src.remaining();
 if (n > remaining()) {
 throw new BufferOverflowException();
 }
 // 一个字节一个字节的写入
 for (int i = 0; i < n; i++) {
 put(src.get());
 }
 return this;
 }
 复制代码

**HeapByteBuffer\#put(ByteBuffer)** 思路是先判断源**ByteBuffer**的类型，如果源**ByteBuffer**是**HeapByteBuffer**，则调用**native**方法**System\#arraycopy**完成批量写入，如果源**ByteBuffer**是在直接内存中分配的，则再判断一下要写入的字节是否大于6，如果大于6就调用**native**方法**Unsafe\#copyMemory**完成批量写入，否则就一个字节一个字节的写入。实现如下。

public ByteBuffer put(ByteBuffer src) {
 if (src instanceof HeapByteBuffer) {
 if (src == this) {
 throw new IllegalArgumentException();
 }
 HeapByteBuffer sb = (HeapByteBuffer) src;
 // 计算源ByteBuffer剩余的字节数
 int n = sb.remaining();
 if (n > remaining()) {
 throw new BufferOverflowException();
 }
 // 调用native方法批量写入
 System.arraycopy(sb.hb, sb.ix(sb.position()),
 hb, ix(position()), n);
 // 更新源ByteBuffer的position
 sb.position(sb.position() + n);
 // 更新当前ByteBuffer的position
 position(position() + n);
 } else if (src.isDirect()) {
 // 计算源ByteBuffer剩余的字节数
 int n = src.remaining();
 if (n > remaining()) {
 throw new BufferOverflowException();
 }
 // 批量写入字节到当前ByteBuffer的hb字节数组中
 src.get(hb, ix(position()), n);
 // 更新当前ByteBuffer的position
 position(position() + n);
 } else {
 super.put(src);
 }
 return this;
 }
 
 // DirectByteBuffer#get(byte[], int, int)
 public ByteBuffer get(byte[] dst, int offset, int length) {
 if (((long) length << 0) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
 checkBounds(offset, length, dst.length);
 int pos = position();
 int lim = limit();
 assert (pos <= lim);
 int rem = (pos <= lim ? lim - pos : 0);
 if (length > rem) {
 throw new BufferUnderflowException();
 }
 Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
 (long) offset << 0,
 (long) length << 0);
 // 更新源ByteBuffer的position
 position(pos + length);
 } else {
 super.get(dst, offset, length);
 }
 return this;
 }
 复制代码

**DirectByteBuffer\#put(ByteBuffer)** 的思路也是先判断源**ByteBuffer**的类型，如果源**ByteBuffer**是**DirectByteBuffer**，则直接使用**native**方法**Unsafe\#copyMemory**完成批量写入，如果源**ByteBuffer**是在堆上分配的，则按照**DirectByteBuffer**的**put(byte\[\], int, int)** 方法的逻辑完成批量写入。实现如下所示。

public ByteBuffer put(ByteBuffer src) {
 if (src instanceof DirectByteBuffer) {
 if (src == this) {
 throw new IllegalArgumentException();
 }
 DirectByteBuffer sb = (DirectByteBuffer) src;
 int spos = sb.position();
 int slim = sb.limit();
 assert (spos <= slim);
 // 计算源ByteBuffer剩余的字节数
 int srem = (spos <= slim ? slim - spos : 0);
 
 int pos = position();
 int lim = limit();
 assert (pos <= lim);
 int rem = (pos <= lim ? lim - pos : 0);
 
 if (srem > rem) {
 throw new BufferOverflowException();
 }
 // 调用native方法完成批量写入
 unsafe.copyMemory(sb.ix(spos), ix(pos), (long) srem << 0);
 // 更新源ByteBuffer的position
 sb.position(spos + srem);
 // 更新当前ByteBuffer的position
 position(pos + srem);
 } else if (src.hb != null) {
 int spos = src.position();
 int slim = src.limit();
 assert (spos <= slim);
 // 计算源ByteBuffer剩余的字节数
 int srem = (spos <= slim ? slim - spos : 0);
 // 调用DirectByteBuffer#put(byte[], int, int)完成批量写入
 put(src.hb, src.offset + spos, srem);
 // 更新源ByteBuffer的position
 src.position(spos + srem);
 } else {
 super.put(src);
 }
 return this;
 }
 
 // DirectByteBuffer#put(byte[], int, int)
 public ByteBuffer put(byte[] src, int offset, int length) {
 if (((long) length << 0) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
 checkBounds(offset, length, src.length);
 int pos = position();
 int lim = limit();
 assert (pos <= lim);
 int rem = (pos <= lim ? lim - pos : 0);
 if (length > rem) {
 throw new BufferOverflowException();
 }
 Bits.copyFromArray(src, arrayBaseOffset,
 (long) offset << 0,
 ix(pos),
 (long) length << 0);
 // 更新当前ByteBuffer的position
 position(pos + length);
 } else {
 super.put(src, offset, length);
 }
 return this;
 }
 复制代码

最后有一点需要说明，调用**put(ByteBuffer)** 方法完成批量字节写入后，源**ByteBuffer**和当前**ByteBuffer**的**position**都会被更新。

Ⅵ. 字节序

上述的几种**put()** 方法都是向**ByteBuffer**写入字节，但其实也是可以直接将**char**，**int**等基础数据类型写入**ByteBuffer**，但在分析这些写入基础数据类型到**ByteBuffer**的**put()** 方法以前，有必要对字节序的相关概念进行演示和说明。

已知在**Java**中一个**int**是四个字节，而一个字节是8位，那么就以数字**23333**为例，示意如下。

![format_png 16][]

那么上述的一个**int**数据，存储在内存中时，如果高位字节存储在内存的低地址，低位字节存储在内存的高地址，这种就称为**大端字节序（Big Endian）**，示意图如下所示。

![format_png 17][]

反之如果低位字节存储在内存的低地址，高位字节存储在内存的高地址，这种就称为**小端字节序（Little Endian）**，示意图如下所示。

![format_png 18][]

上述其实是**主机字节序**，表示计算机内存中字节的存储顺序。在**Java**中，数据的存储默认是按照**大端字节序**来存储的。

然后还有一种叫做**网络字节序**，表示网络传输中字节的传输顺序，分类如下。

1.  **大端字节序（Big Endian）**。从二进制数据的高位开始传输；
2.  **小端字节序（Little Endian）**。从二进制数据的低位开始传输。

在网络传输中，默认按照**大端字节序**来传输。

Ⅶ. putInt(int)

**putInt(int)** 方法是**ByteBuffer**定义的用于直接写入一个**int**的抽象方法，先看**HeapByteBuffer**的实现，如下所示。

public ByteBuffer putInt(int x) {
        // 通过nextPutIndex(4)方法拿到当前position，并让position加4
        // 然后调用Bits#putInt完成写入，其中bigEndian默认是true
        Bits.putInt(this, ix(nextPutIndex(4)), x, bigEndian);
        return this;
    }
    
    // Bits#putInt
    static void putInt(ByteBuffer bb, int bi, int x, boolean bigEndian) {
        if (bigEndian) {
            putIntB(bb, bi, x);
        } else {
            putIntL(bb, bi, x);
        }
    }
    
    // Bits#putIntB
    static void putIntB(ByteBuffer bb, int bi, int x) {
        // 通过Bits#int3方法拿到x的第3字节（最高位字节）
        // 然后写入到hb字节数组的索引为bi的位置
        bb._put(bi    , int3(x));
        // 通过Bits#int2方法拿到x的第2字节（次高位字节）
        // 然后写入到hb字节数组的索引为bi+1的位置
        bb._put(bi + 1, int2(x));
        // 通过Bits#int1方法拿到x的第1字节（次低位字节）
        // 然后写入到hb字节数组的索引为bi+2的位置
        bb._put(bi + 2, int1(x));
        // 通过Bits#int0方法拿到x的第0字节（最低位字节）
        // 然后写入到hb字节数组的索引为bi+3的位置
        bb._put(bi + 3, int0(x));
    }
    
    // Bits#int3
    private static byte int3(int x) {
        return (byte) (x >> 24);
    }
    
    // HeapByteBuffer#_put
    void _put(int i, byte b) {
        hb[i] = b;
    }
    复制代码

**HeapByteBuffer**实现的**putInt(int)** 方法中，会依次将**int**的高位到低位写入到**hb**字节数组的低索引到高索引，而在堆中，内存地址是由低到高的，也就是随着数组索引的增加，内存地址也会逐渐增高，所以上述的就是按照大端字节序的方式来直接写入一个**int**。

再看一下**DirectByteBuffer**对**putInt(int)** 方法的实现，如下所示。

public ByteBuffer putInt(int x) {
 // 通过nextPutIndex(4)方法拿到当前position，并让position加4
 // 通过ix()方法拿到实际要写入的内存地址
 putInt(ix(nextPutIndex((1 << 2))), x);
 return this;
 }
 
 // DirectByteBuffer#putInt(long, int)
 private ByteBuffer putInt(long a, int x) {
 if (unaligned) {
 int y = (x);
 unsafe.putInt(a, (nativeByteOrder ? y : Bits.swap(y)));
 } else {
 // 调用Bits#putInt完成写入，其中bigEndian默认是true
 Bits.putInt(a, x, bigEndian);
 }
 return this;
 }
 
 // Bits#putInt
 static void putInt(long a, int x, boolean bigEndian) {
 if (bigEndian) {
 putIntB(a, x);
 } else {
 putIntL(a, x);
 }
 }
 
 // Bits#putIntB
 static void putIntB(long a, int x) {
 // 通过Bits#int3方法拿到x的第3字节（最高位字节）
 // 然后写入到直接内存地址为a的位置
 _put(a , int3(x));
 // 通过Bits#int2方法拿到x的第2字节（次高位字节）
 // 然后写入到直接内存地址为a+1的位置
 _put(a + 1, int2(x));
 // 通过Bits#int1方法拿到x的第1字节（次低位字节）
 // 然后写入到直接内存地址为a+2的位置
 _put(a + 2, int1(x));
 // 通过Bits#int0方法拿到x的第0字节（最低位字节）
 // 然后写入到直接内存地址为a+3的位置
 _put(a + 3, int0(x));
 }
 
 // Bits#int3
 private static byte int3(int x) {
 return (byte) (x >> 24);
 }
 
 // Bits#_put
 private static void _put(long a, byte b) {
 unsafe.putByte(a, b);
 }
 复制代码

在**DirectByteBuffer**的实现中，会依次将**int**的高位到低位写入到直接内存的低地址到高地址，整体也是一个大端字节序的写入方式。

Ⅷ. putInt(int, int)

**putInt(int, int)** 方法可以在指定位置写入**int**，同时也不会更改**position**。**putInt(int, int)** 方法实现原理和**putInt(int)** 一样，故这里不再赘述。

其它的写入非字节的方法，本质和写入**int**一致，故也不再赘述。

6. ByteBuffer的读操作

**ByteBuffer**中定义了大量读操作相关的抽象方法，如下图所示。

![format_png 19][]

总体可以进行如下归类。

![format_png 20][]

下面将对上述部分读方法结合源码进行说明。

Ⅰ. get()

**get()** 方法用于读取一个字节，**HeapByteBuffer**的实现如下所示。

public byte get() {
        return hb[ix(nextGetIndex())];
    }
    复制代码

上述方法是读取字节数组中**position**索引位置的字节，然后**position**加1。再看一下**DirectByteBuffer**对**get()** 方法的实现，如下所示。

public byte get() {
        return ((unsafe.getByte(ix(nextGetIndex()))));
    }
    复制代码

上述方法是基于**native**方法拿到**address + position**位置的字节然后**position**加1。

Ⅱ. get(int)

**get(int)** 方法用于读取指定位置的字节，**HeapByteBuffer**的实现如下所示。

public byte get(int i) {
        return hb[ix(checkIndex(i))];
    }
    复制代码

上述方法会读取字节数组中指定索引位置的字节，注意**position**不会改变。再看一下**DirectByteBuffer**对**get(int)** 方法的实现，如下所示。

public byte get(int i) {
        return ((unsafe.getByte(ix(checkIndex(i)))));
    }
    复制代码

上述方法是基于**native**方法拿到指定位置的字节，同样，**position**不会改变。

Ⅲ. get(byte\[\], int, int)

**get(byte\[\], int, int)** 方法用于将当前**ByteBuffer**从**position**位置开始往后的若干字节写入到目标字节数组的指定位置。**ByteBuffer**，**HeapByteBuffer**和**DirectByteBuffer**都有相应的实现，下面分别看一下。

**ByteBuffer**对**get(byte\[\], int, int)** 方法的实现中是一个字节一个字节的读取并写入，如下所示。

public ByteBuffer get(byte[] dst, int offset, int length) {
 checkBounds(offset, length, dst.length);
 if (length > remaining()) {
 throw new BufferUnderflowException();
 }
 int end = offset + length;
 // 写入目标数组的开始位置是offset
 // 共写入length个字节
 for (int i = offset; i < end; i++) {
 dst[i] = get();
 }
 return this;
 }
 复制代码

**HeapByteBuffer**对**get(byte\[\], int, int)** 方法的实现中，是调用**System\#arraycopy**本地方法来进行批量拷贝写入，效率比一个字节一个字节的读取并写入更高，且最后会更新当前**HeapByteBuffer**的**position**。

public ByteBuffer get(byte[] dst, int offset, int length) {
        checkBounds(offset, length, dst.length);
        if (length > remaining()) {
            throw new BufferUnderflowException();
        }
        // 调用native方法来批量写入字节到dst字节数组
        System.arraycopy(hb, ix(position()), dst, offset, length);
        // 更新当前HeapByteBuffer的position
        position(position() + length);
        return this;
    }
    复制代码

**DirectByteBuffer**对**get(byte\[\], int, int)** 方法的实现中，会先判断需要读取并写入到目标字节数组中的字节数是否大于6，大于6时会调用**native**方法来批量写入，否则就一个字节一个字节的读取并写入，最终还会更新当前**DirectByteBuffer**的**position**。

public ByteBuffer get(byte[] dst, int offset, int length) {
 if (((long) length << 0) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
 // 批量写入的字节数大于6个
 checkBounds(offset, length, dst.length);
 int pos = position();
 int lim = limit();
 assert (pos <= lim);
 int rem = (pos <= lim ? lim - pos : 0);
 if (length > rem) {
 throw new BufferUnderflowException();
 }
 // 最终调用到Unsafe#copyMemory方法完成批量拷贝写入
 Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
 (long) offset << 0,
 (long) length << 0);
 // 更新当前DirectByteBuffer的position
 position(pos + length);
 } else {
 // 批量写入的字节数小于等于6个
 // 则一个字节一个字节的读取并写入
 super.get(dst, offset, length);
 }
 return this;
 }
 复制代码

Ⅳ. get(byte\[\])

**get(byte\[\])** 方法会从当前**ByteBuffer**的**position**位置开始，读取目标字节数组长度个字节，然后依次写入到目标字节数组。**get(byte\[\])** 方法由**ByteBuffer**实现，如下所示。

public ByteBuffer get(byte[] dst) {
        return get(dst, 0, dst.length);
    }
    复制代码

那么本质还是依赖**get(byte\[\], int, int)** 方法，只不过将**offset**指定为了0（表示从**dst**字节数组的索引为0的位置开始写入），将**length**指定为了**dst.length**（表示要写满**dst**字节数组）。

Ⅴ. getInt()

**getInt()** 方法表示从**ByteBuffer**中读取一个**int**值，先看一下**HeapByteBuffer**的实现，如下所示。

public int getInt() {
 // 通过nextGetIndex(4)拿到当前position，然后position加4
 // 默认bigEndian为true，表示以大端字节序的方式读取int
 return Bits.getInt(this, ix(nextGetIndex(4)), bigEndian);
 }
 
 // Bits#getInt
 static int getInt(ByteBuffer bb, int bi, boolean bigEndian) {
 return bigEndian ? getIntB(bb, bi) : getIntL(bb, bi) ;
 }
 
 // Bits#getIntB
 static int getIntB(ByteBuffer bb, int bi) {
 // 依次拿到低索引到高索引的字节
 // 这些字节依次对应int值的高位到低位
 // 最终调用makeInt()方法拼接成int值
 return makeInt(bb._get(bi),
 bb._get(bi + 1),
 bb._get(bi + 2),
 bb._get(bi + 3));
 }
 
 // Bits#makeInt
 static private int makeInt(byte b3, byte b2, byte b1, byte b0) {
 return (((b3) << 24) |
 ((b2 & 0xff) << 16) |
 ((b1 & 0xff) << 8) |
 ((b0 & 0xff)));
 }
 
 // HeapByteBuffer#_get
 byte _get(int i) {
 return hb[i];
 }
 复制代码

上述方法的实现中，首先获取到当前**HeapByteBuffer**的**position**，然后从**position**位置开始依次读取四个字节，因为默认情况下是大端字节序（也就是写和读都是按照大端字节序的方式），所以读取到的字节应该依次对应**int**值的高位到低位，所以最终会在**Bits\#makeInt**方法中将四个字节通过错位或的方式得到**int**值。

再看一下**DirectByteBuffer**对**getInt()** 方法的实现，如下所示。

public int getInt() {
 // 通过nextGetIndex(4)拿到当前position，然后position加4
 // 通过ix()方法拿到操作的起始地址是address + position
 return getInt(ix(nextGetIndex((1 << 2))));
 }
 
 // DirectByteBuffer#getInt(long)
 private int getInt(long a) {
 if (unaligned) {
 int x = unsafe.getInt(a);
 return (nativeByteOrder ? x : Bits.swap(x));
 }
 // 默认bigEndian为true，表示默认大端字节序
 return Bits.getInt(a, bigEndian);
 }
 
 // Bits#getInt
 static int getInt(long a, boolean bigEndian) {
 return bigEndian ? getIntB(a) : getIntL(a) ;
 }
 
 // Bits#getIntB
 static int getIntB(long a) {
 // 从低地址拿到int值的高位
 // 从高地址拿到int值的低位
 // 然后拼接得到最终的int值
 return makeInt(_get(a),
 _get(a + 1),
 _get(a + 2),
 _get(a + 3));
 }
 
 // Bits#_get
 private static byte _get(long a) {
 return unsafe.getByte(a);
 }
 
 // Bits#makeInt
 static private int makeInt(byte b3, byte b2, byte b1, byte b0) {
 return (((b3) << 24) |
 ((b2 & 0xff) << 16) |
 ((b1 & 0xff) << 8) |
 ((b0 & 0xff)));
 }
 复制代码

**DirectByteBuffer**对**getInt()** 方法的整体实现思路和**HeapByteBuffer**是一致的，在默认大端字节序的情况下，从低地址拿到**int**值的高位字节，从高地址拿到**int**值的低位字节，最后通过错位或的方式得到最终的**int**值。请注意，操作完成后，**position**都会加4，这是因为一个**int**占四个字节，也就是相当于读取了4个字节。

Ⅵ. getInt(int)

**getInt(int)** 方法能够从指定位置读取一个**int**值，实现思路和**getInt()** 方法完全一致，故这里不再赘述，但需要注意的是，**getInt(int)** 方法读取一个**int**值后，不会改变**position**。

其它的非字节的读取，本质和**int**值的读取一样，故也不再赘述。

7. ByteBuffer的使用示例

在**Log4j2**日志框架中，最终在将日志进行输出时，对日志内容的处理就有使用到**ByteBuffer**，下面一起来简单的看一下。（无需关注**Log4j2**的实现细节）

在将日志内容进行标准输出时，最终是通过**OutputStreamManager**完成将日志内容输出，它里面有一个字段就是**HeapByteBuffer**，用于存储日志内容的字节数据。下面先看一下**org.apache.logging.log4j.core.layout.TextEncoderHelper\#writeEncodedText**方法，这里面会有**OutputStreamManager**的**ByteBuffer**如何被写入的相关逻辑。

private static void writeEncodedText(final CharsetEncoder charsetEncoder, final CharBuffer charBuf,
            final ByteBuffer byteBuf, final ByteBufferDestination destination, CoderResult result) {
        
        ......
        
        if (byteBuf != destination.getByteBuffer()) {
            // 这里的byteBuf存储了处理后的日志内容
            // 调用flip()方法来进入读模式
            byteBuf.flip();
            // 这里的destination就是OutputStreamManager
            // 这里会将byteBuf的内容写到OutputStreamManager的ByteBuffer中
            destination.writeBytes(byteBuf);
            // 切换为写模式，也就是position置0，重置limit等于capacity等
            byteBuf.clear();
        }
    }
    
    // OutputStreamManager#writeBytes
    public void writeBytes(final ByteBuffer data) {
        if (data.remaining() == 0) {
            return;
        }
        synchronized (this) {
            ByteBufferDestinationHelper.writeToUnsynchronized(data, this);
        }
    }
    
    // ByteBufferDestinationHelper#writeToUnsynchronized
    public static void writeToUnsynchronized(final ByteBuffer source, final ByteBufferDestination destination) {
        // 拿到OutputStreamManager中的HeapByteBuffer
        // 这里称OutputStreamManager中的HeapByteBuffer为目标ByteBuffer
        ByteBuffer destBuff = destination.getByteBuffer();
        // 如果源ByteBuffer剩余可读字节多于目标ByteBuffer剩余可写字节
        // 则循环的写满目标ByteBuffer再读取完目标ByteBuffer
        // 最终就是需要将源ByteBuffer的字节全部由目标ByteBuffer消费掉
        while (source.remaining() > destBuff.remaining()) {
            final int originalLimit = source.limit();
            // 先将源ByteBuffer的limit设置为当前position + 目标ByetBuffer剩余可写字节数
            source.limit(Math.min(source.limit(), source.position() + destBuff.remaining()));
            // 将源ByteBuffer当前position到limit的字节写到目标ByteBuffer中
            destBuff.put(source);
            // 恢复源ByteBuffer的limit
            source.limit(originalLimit);
            // 目标ByteBuffer先将已有的字节全部标准输出
            // 然后返回一个写模式的目标ByteBuffer
            destBuff = destination.drain(destBuff);
        }
        
        // 到这里说明源ByteBuffer剩余可读字节小于等于目标ByteBuffer剩余可写字节
        // 则将源ByteBuffer剩余可读字节全部写到目标ByteBuffer中
        // 后续会在其它地方将这部分内容全部标准输出
        destBuff.put(source);
    }
    
    // OutputStreamManager#drain
    public ByteBuffer drain(final ByteBuffer buf) {
        flushBuffer(buf);
        return buf;
    }
    
    // OutputStreamManager#flushBuffer
    protected synchronized void flushBuffer(final ByteBuffer buf) {
        // 目标ByteBuffer切换为读模式
        ((Buffer) buf).flip();
        try {
            if (buf.remaining() > 0) {
                // 拿到HeapByteBuffer中的字节数组
                // 最终调用到PrintStream来标准输出字节数组中的字节内容
                writeToDestination(buf.array(), buf.arrayOffset() + buf.position(), buf.remaining());
            }
        } finally {
            // 目标ByteBuffer切换回写模式
            buf.clear();
        }
    }
    复制代码

相信如果阅读完本文，那么上述**Log4j2**中对于**ByteBuffer**的使用，肯定都是能看明白的，虽然**Log4j2**中有大量的基于**ByteBuffer**的使用，但是最终的标准输出还是基于**Java**的传统**IO**来输出的，那么为什么中间还要用**ByteBuffer**来多处理一下呢，其实也就是因为**ByteBuffer**在读写字节时会考虑性能问题，会使用到性能更高的**native**方法来批量的操作字节数据，因此以快著称的**Log4j2**选择了**NIO**中的**ByteBuffer**。

8. ByteBuffer的缺点

如果要讨论**ByteBuffer**的缺点，其实可以结合第7小节的使用示例来一并讨论。

首先就是**读写模式的切换**。在第7小节示例中，会发现存在多处调用**flip()** 方法来切换到读模式，调用**clear()** 方法来切换到写模式，这种模式的切换，既麻烦，还容易出错。

然后就是**无法扩容**。在第7小节示例中，有一个细节就是因为**ByteBuffer**容量太小了，无法一次写完所有字节数据，所以就只能循环的写满读取然后再写满这样子来操作，如果能扩容就不用这么麻烦了。

最后就是**线程不安全**。**ByteBuffer**自身并没有提供对线程安全的保护，要实现线程安全，需要使用者自己通过其它的并发语义来实现。

## 总结 ##

本文对**ByteBuffer**的分析可以参照下图。

![format_png 21][]

为啥**NIO**中偏分析**ByteBuffer**呢，因为**Netty**中的缓存是**ByteBuf**，其对**ByteBuffer**做了改良，在下一篇文章中，将对**Netty**中的缓存**ByteBuf**进行详细分析。

[format_png]: https://img-blog.csdnimg.cn/img_convert/be715c68a17970508f7a8fa6224a7c5c.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/a8c66a8ccfa308a56373d697604c54dd.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/2dcfdab4db11686efa19e89a1f2c6875.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/edff253245fabc534c3f4808caaae94b.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/204450a33c383be3a0f1153e77cc4db2.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/3437d622eba0bce93339f4d19f786ed9.webp?x-oss-process=image/format,png
[format_png 6]: https://img-blog.csdnimg.cn/img_convert/7e5ee1a6b47250214e4716d69b37873c.webp?x-oss-process=image/format,png
[format_png 7]: https://img-blog.csdnimg.cn/img_convert/4f3f47c2309f4390faa6906e61b2ac99.webp?x-oss-process=image/format,png
[format_png 8]: https://img-blog.csdnimg.cn/img_convert/264c8e9790abe33510fd307bfe5dd7ed.webp?x-oss-process=image/format,png
[format_png 9]: https://img-blog.csdnimg.cn/img_convert/96a4feadc43725beb03b66bfed77bfc1.webp?x-oss-process=image/format,png
[format_png 10]: https://img-blog.csdnimg.cn/img_convert/cc78330b49fe8193292b2b723a6cd7c1.webp?x-oss-process=image/format,png
[format_png 11]: https://img-blog.csdnimg.cn/img_convert/edc610ba39d71690888518a93055e01c.webp?x-oss-process=image/format,png
[format_png 12]: https://img-blog.csdnimg.cn/img_convert/e2e0369b1a77218dfeeb101477e5395d.webp?x-oss-process=image/format,png
[format_png 13]: https://img-blog.csdnimg.cn/img_convert/c18769002962daaa26011cc339f9625e.webp?x-oss-process=image/format,png
[format_png 14]: https://img-blog.csdnimg.cn/img_convert/2dada32eacf68178537765179c0070cb.webp?x-oss-process=image/format,png
[format_png 15]: https://img-blog.csdnimg.cn/img_convert/fbdff60835585345c02a1ba8a7feeed9.webp?x-oss-process=image/format,png
[format_png 16]: https://img-blog.csdnimg.cn/img_convert/3a95abd1880eb64a08e6794760050f29.webp?x-oss-process=image/format,png
[format_png 17]: https://img-blog.csdnimg.cn/img_convert/eaef1c957c900b64c16db667bf3ee245.webp?x-oss-process=image/format,png
[format_png 18]: https://img-blog.csdnimg.cn/img_convert/cb3fb18e787b014a79935cb61e0e3af0.webp?x-oss-process=image/format,png
[format_png 19]: https://img-blog.csdnimg.cn/img_convert/c614a837ee6b5b14dbeb94f5eb79f20e.webp?x-oss-process=image/format,png
[format_png 20]: https://img-blog.csdnimg.cn/img_convert/1ed3570263e26e9b561b8fc116ee0bdc.webp?x-oss-process=image/format,png
[format_png 21]: https://img-blog.csdnimg.cn/img_convert/4ac48ad7979ad704351fc34d264a6268.webp?x-oss-process=image/format,png