Netty 之 ByteBuf 分析

概述

Netty 中的 ByteBuf 和 NIO 中的 ByteBuffer 的区别。

• 1、Netty 中的 ByteBuf 支持动态的扩容和缩容。而 NIO 中的 ByteBuffer不支持。
• 2、Netty 中的 ByteBuf 使用了 readIndex 和 writeIndex 来进行读写操作，而 NIO 中的 ByteBuffer 读写时，还需要 filp()、rewind() 等操作进行读写切换才能读写。
• 3、Netty 中的 ByteBuf 使用了 markedReaderIndex 和 markedWriterIndex 来进行标记，读写时标记互不影响。而 NIO 中的 ByteBuffer 则只有一个 mark。读写切换时 mark都重置为 -1。
• 4、Netty 还支持 ByteBuf 的池化技术。
  比如：
  PooledHeapByteBuf
  PooledUnsafeHeapByteBuf
  PooledDirectByteBuf
  PooledUnsafeDirectByteBuf

下面我们简单分析下 Netty 中的 ByteBuf。

writeByte() 方法

Netty 的 ByteBuf 支持动态扩容。在 put 操作的时候会对剩余可用空间进行校验。如果剩余空间不足，则会自动扩容 。NIO 中的 ByteBuffer 不支持动态扩容。
Netty 中的 ByteBuf 还简化 NIO 中的 ByteBuffer 读写问题。
NIO 中 ByteBuffer，使用 postion、limit、capacity、mark 来维护读写操作、每次读写还需要 flip 等操作，而 Netty 中的 ByteBuf 简化了读写操作，用 readerIndex 和 writeIndex 来简化读写操作、读写不需要来回切换。

public ByteBuf writeByte(int value) {
    // 确保 buffer 可写，并且处理扩容、缩容
    ensureWritable0(1);
    // 写入 value，并增加 writerIndex
    _setByte(writerIndex++, value);
    return this;
}

final void ensureWritable0(int minWritableBytes) {
    // 1、判断是否可访问
    ensureAccessible();
    // 2、如果写入字节小于可写字节数，则跳出检查
    if (minWritableBytes <= writableBytes()) {
        return;
    }
    if (checkBounds) {
        // 3、如果写入字节大于 Buffer 剩余可写入量，则抛出异常
        if (minWritableBytes > maxCapacity - writerIndex) {
            throw new IndexOutOfBoundsException(String.format(
                    "writerIndex(%d) + minWritableBytes(%d) exceeds maxCapacity(%d): %s",
                    writerIndex, minWritableBytes, maxCapacity, this));
        }
    }

    // 4、计算 Buffer 的容量
    int newCapacity = alloc().calculateNewCapacity(writerIndex + minWritableBytes, maxCapacity);

    // 5、调整 Buffer 的容量大小 （扩大或减小 capacity）
    capacity(newCapacity);
}

1、判断是否可访问
2、如果写入字节小于可写字节数，则跳出检查
3、如果写入字节大于 Buffer 剩余可写入量，则抛出异常
4、计算 Buffer 的容量
5、调整 Buffer 的容量大小 （扩大或减小 capacity）

计算 Buffer 扩容大小

/**
 * minNewCapacity 需要的支持的最小容量（写索引+当前写入字节）
 * maxCapacity 最大容量
 */
public int calculateNewCapacity(int minNewCapacity, int maxCapacity) {
    // 参数合法性校验
    if (minNewCapacity < 0) {
        throw new IllegalArgumentException("minNewCapacity: " + minNewCapacity + " (expected: 0+)");
    }
    if (minNewCapacity > maxCapacity) {
        throw new IllegalArgumentException(String.format(
                "minNewCapacity: %d (expected: not greater than maxCapacity(%d)",
                minNewCapacity, maxCapacity));
    }
    
    // 容量计算阈值，如果 Buffer 容量小于4M，则每次都扩容2倍，大于4M，则每次扩容4M
    final int threshold = CALCULATE_THRESHOLD; // 4 MiB page
    // 如果需要写入的容量大小等于 threshold，则直接返回 threshold值。
    if (minNewCapacity == threshold) {
        return threshold;
    }

    // 如果 minNewCapacity 超过 threshold, 就不再每次扩容2倍
    if (minNewCapacity > threshold) {
        int newCapacity = minNewCapacity / threshold * threshold;
        // 这块逻辑大概意思：需要扩容的最小容量+4M，如果超过 maxCapacity，则把设置为 maxCapacity
        if (newCapacity > maxCapacity - threshold) {
            newCapacity = maxCapacity;
        } 
        // 否则，每次扩容4M
        else {
            newCapacity += threshold;
        }
        return newCapacity;
    }

    // 不超过 threshold 阈值. 则每次扩容两倍，如果小于64的，则直接返回64。
    int newCapacity = 64;
    while (newCapacity < minNewCapacity) {
        newCapacity <<= 1;
    }

    return Math.min(newCapacity, maxCapacity);
}

这里的主要逻辑为：
1、threshold 设置为 4M，当需要扩容时判断 minNewCapacity 是否等于 threshold ，如果等于则使用 threshold 作为缓冲区大小。
2、如果minNewCapacity 容量大于 threshold 容量，就不能采用每次扩容2倍的方式进行扩容，而是采用每次扩容 4M 的方式。扩容时还需要判断是否达到最大值，如果达到最大值，则使用最大值。
3、如果 minNewCapacity 容量小于 threshold 容量，就成倍的进行扩容，最小容量为64。

调整 Buffer 的容量大小

@Override
public ByteBuf capacity(int newCapacity) {
    // 检查 newCapacity 是否在 0 - maxCapacity 之间
    checkNewCapacity(newCapacity);

    int oldCapacity = array.length;
    byte[] oldArray = array;
    // 如果 newCapacity 大于 oldCapacity 则扩容
    if (newCapacity > oldCapacity) {
        // 创建一个长度为 newCapacity 的 byte[] 数组
        byte[] newArray = allocateArray(newCapacity);
        // 把数据 copy 到新的 byte[] 数组中
        System.arraycopy(oldArray, 0, newArray, 0, oldArray.length);
        // newArray 替换原来的 array
        setArray(newArray);
        // UnpooledHeapByteBuf.freeArray() 无操作，空方法。
        freeArray(oldArray);
    } 
    // 如果 newCapacity 小于 oldCapacity 则缩减容量
    else if (newCapacity < oldCapacity) {
        // 创建一个长度为 newCapacity 的 byte[] 数组
        byte[] newArray = allocateArray(newCapacity);
        int readerIndex = readerIndex();
        // 如果读索引小于 Buffer 大小
        if (readerIndex < newCapacity) {
            int writerIndex = writerIndex();
            // 写索引大于 newCapacity， 则把写索引设置为 newCapacity
            if (writerIndex > newCapacity) {
                writerIndex(writerIndex = newCapacity);
            }
            // 把数据 copy 到新的 byte[] 数组中
            System.arraycopy(oldArray, readerIndex, newArray, readerIndex, writerIndex - readerIndex);
        } 
        // 如果读索引大于 newCapacity，则说明无可用的读写。则把读写索引设置为 newCapacity
        else {
            setIndex(newCapacity, newCapacity);
        }
        // newArray 替换原来的 array
        setArray(newArray);
        freeArray(oldArray);
    }
    return this;
}

discardReadBytes

discardReadBytes 就相当于 NIO ByteBuffer 中的 compact() 方法，压缩缓冲区，从而可以在缓冲区中写更多的数据。

调用 discardReadBytes() 方法时需要注意的是，每次 discard 操作，都会发生字节数组的内存复制，所以频繁的调用会导致性能下降，因此在调用之前确认下是否需要每次调用。

• discardReadBytes() 之前

 
    +-------------------+------------------+------------------+
    | discardable bytes |  readable bytes  |  writable bytes  |
    +-------------------+------------------+------------------+
    |                   |                  |                  |
    0      <=      readerIndex   <=   writerIndex    <=    capacity

• discardReadBytes() 之后

   +------------------+--------------------------------------+
   |  readable bytes  |    writable bytes (got more space)   |
   +------------------+--------------------------------------+
   |                  |                                      |
readerIndex (0) <= writerIndex (decreased)        <=        capacity

通过discard前后可用看出，discard后将会有更多的空间可用写入数据。

/**
 * 丢弃掉已经读过的数据，相当于 NIO ByteBuffer.compact() 方法。
 */
@Override
public ByteBuf discardReadBytes() {
    // 判断是否可访问
    ensureAccessible();
    // 如果 readerIndex = 0，说明没有已经读取过的数据，不需要 discard
    if (readerIndex == 0) {
        return this;
    }
    // 如果 readerIndex != writerIndex，则需要调整读写索引，并移动数据
    if (readerIndex != writerIndex) {
        // 复制readerIndex和writerIndex 之间的数据，前移到0的坐标位置。
        setBytes(0, this, readerIndex, writerIndex - readerIndex);
        // 修改写索引的值
        writerIndex -= readerIndex;
        // 调整 marker 值
        adjustMarkers(readerIndex);
        // 读索引设置为0
        readerIndex = 0;
    } 
    // 如果读写索引相等，说明没有要读取的数据，则直接把 读写索引置位0即可。相当于清空索引。
    else {
        // 调整 marker 值
        adjustMarkers(readerIndex);
        // 读写索引直接设置为0，即可。
        writerIndex = readerIndex = 0;
    }
    return this;
}

调整 读标记 和 写标记

Netty 的 ByteBuf 使用了 markedReaderIndex 和 markedWriterIndex 来分别代表读写的标记。读写标记会不影响。

protected final void adjustMarkers(int decrement) {
    int markedReaderIndex = this.markedReaderIndex;
    // 如果读标记小于discard的大小，读标记设置为0。
    if (markedReaderIndex <= decrement) {
        this.markedReaderIndex = 0;
        int markedWriterIndex = this.markedWriterIndex;
        // 如果写标记小于 decrement，则把写标记置位0，否则为 写标记减去 decrement 
        if (markedWriterIndex <= decrement) {
            this.markedWriterIndex = 0;
        } else {
            this.markedWriterIndex = markedWriterIndex - decrement;
        }
    } else {
        this.markedReaderIndex = markedReaderIndex - decrement;
        markedWriterIndex -= decrement;
    }
}

clear() 方法

public ByteBuf clear() {
    // 设置读写索引都为0
    readerIndex = writerIndex = 0;
    return this;
}

只需要把 readerIndex 和 writerIndex 都设置为0即可，而不需要清楚 Buffer 里面的数据。因为再写的时候会覆盖掉。

• clear() 之前

+-------------------+------------------+------------------+
| discardable bytes |  readable bytes  |  writable bytes  |
+-------------------+------------------+------------------+
|                   |                  |                  |
0      <=      readerIndex   <=   writerIndex    <=    capacity

• clear() 之后

+---------------------------------------------------------+
|             writable bytes (got more space)             |
+---------------------------------------------------------+
|                                                         |
0 = readerIndex = writerIndex            <=            capacity