netty ByteBuf分析

1.Heap Buffer(堆缓冲区)

2.Direct Buffer(直接缓冲区)

3.Composite Buffer(复合缓冲区)

4.PooledByteBuf 池缓冲

    readerInex 当前读取索引
    writerIndex 当前写索引
    0~readerInex 之间被视为 discard,调用 discardReadBytes() 会释放空间

        @Override
        public ByteBuf discardReadBytes() {
            ensureAccessible();
            if (readerIndex == 0) {
                return this;
            }

            if (readerIndex != writerIndex) {
                setBytes(0, this, readerIndex, writerIndex - readerIndex);
                writerIndex -= readerIndex;
                adjustMarkers(readerIndex);
                readerIndex = 0;
            } else {
                adjustMarkers(readerIndex);
                writerIndex = readerIndex = 0;
            }
            return this;
        }

        @Override
        public ByteBuf ensureWritable(int minWritableBytes) {
            if (minWritableBytes < 0) {
                throw new IllegalArgumentException(String.format(
                        "minWritableBytes: %d (expected: >= 0)", minWritableBytes));
            }

            if (minWritableBytes <= writableBytes()) {
                return this;
            }
            //写入数据长度大于剩余长度（默认int max - wirter）
            if (minWritableBytes > maxCapacity - writerIndex) {
                throw new IndexOutOfBoundsException(String.format(
                        "writerIndex(%d) + minWritableBytes(%d) exceeds maxCapacity(%d): %s",
                        writerIndex, minWritableBytes, maxCapacity, this));
            }

            // Normalize the current capacity to the power of 2.
            //计算新空间大小
            int newCapacity = calculateNewCapacity(writerIndex + minWritableBytes);

            // Adjust to the new capacity.
            //不同类型扩展实现 处理过程实际是直接修改JDK ByteBuffer
            capacity(newCapacity);
            return this;
        }

        private int calculateNewCapacity(int minNewCapacity) {
            final int maxCapacity = this.maxCapacity;
            final int threshold = 1048576 * 4; // 4 MiB page

            if (minNewCapacity == threshold) {
                return threshold;
            }

            // If over threshold, do not double but just increase by threshold.
            //当超过4M时，直接扩展4M空间
            if (minNewCapacity > threshold) {
                int newCapacity = minNewCapacity / threshold * threshold;
                if (newCapacity > maxCapacity - threshold) {
                    newCapacity = maxCapacity;
                } else {
                    newCapacity += threshold;
                }
                return newCapacity;
            }

            // Not over threshold. Double up to 4 MiB, starting from 64.
            //以双倍扩展空间
            int newCapacity = 64;
            while (newCapacity < minNewCapacity) {
                newCapacity <<= 1;
            }

            return Math.min(newCapacity, maxCapacity);
        }