主要成员变量
static final ResourceLeakDetector<ByteBuf> leakDetector = new ResourceLeakDetector<ByteBuf>(ByteBuf.class); int readerIndex; // 读索引 private int writerIndex; // 写索引 private int markedReaderIndex;// private int markedWriterIndex;//mark private int maxCapacity;// 最大容量 private SwappedByteBuf swappedBuf;
读操作簇
@Override public ByteBuf readBytes(byte[] dst, int dstIndex, int length) { checkReadableBytes(length); getBytes(readerIndex, dst, dstIndex, length); readerIndex += length; return this; }
在读之前，首先对缓冲区的可用空间进行校验，如下
/** * Throws an {@link IndexOutOfBoundsException} if the current * {@linkplain #readableBytes() readable bytes} of this buffer is less * than the specified value. */ protected final void checkReadableBytes(int minimumReadableBytes) { ensureAccessible(); if (minimumReadableBytes < 0) { throw new IllegalArgumentException("minimumReadableBytes: " + minimumReadableBytes + " (expected: >= 0)"); } if (readerIndex > writerIndex - minimumReadableBytes) { throw new IndexOutOfBoundsException(String.format( "readerIndex(%d) + length(%d) exceeds writerIndex(%d): %s", readerIndex, minimumReadableBytes, writerIndex, this)); } }
如果长度小于0，则抛出IllegalArgumentException异常提示参数非法，如果可写的字节数小于需要读取的长度，则抛出IndexOutOfBoundsException异常，由于异常中封装了相信的异常信息，可以很方便的进行问题定位。
校验通过之后，调用getBytes方法，从当前的读索引开始，复制length个字节到目标byte数组中，由于不同的子类复制操作的技术实现细节不同，因此该方法由子类实现。
/** * Transfers this buffer's data to the specified destination starting at * the specified absolute {@code index}. * This method does not modify {@code readerIndex} or {@code writerIndex} * of this buffer. * * @param dstIndex the first index of the destination * @param length the number of bytes to transfer * * @throws IndexOutOfBoundsException * if the specified {@code index} is less than {@code 0}, * if the specified {@code dstIndex} is less than {@code 0}, * if {@code index + length} is greater than * {@code this.capacity}, or * if {@code dstIndex + length} is greater than * {@code dst.length} */ public abstract ByteBuf getBytes(int index, byte[] dst, int dstIndex, int length);
如果读取成功，需要对读索引进行递增：readIndex +=length.
写操作簇
写操作的公共行为在AbstractByteBuf中实现，
@Override public ByteBuf writeBytes(byte[] src, int srcIndex, int length) { ensureWritable(length); setBytes(writerIndex, src, srcIndex, length); writerIndex += length; return this; }
将源字节数组中的从srcIndex 开始，到 srcIndex + length 截至的字节数组写入到当前的 ByteBuf。
首先对写入字节数组的长度进行合法性校验，如下
@Override public ByteBuf ensureWritable(int minWritableBytes) { if (minWritableBytes < 0) { throw new IllegalArgumentException(String.format( "minWritableBytes: %d (expected: >= 0)", minWritableBytes)); } if (minWritableBytes <= writableBytes()) { return this; } 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. capacity(newCapacity); return this; }
如果写入的字节数组长度小于0，则抛出 IllegalArgumentException 异常；如果写入的字节数组长度小于当前 ByteBuf 可写的字节数，说明可以写入成功，直接返回；如果写入的字节数组长度大于可以动态扩展的最大可写字节数，说明缓冲区无法写入超过其最大容量的字节数组，抛出 IndexOutOfBoundsException 异常。
如果当前写入的字节数组长度虽然大于目前 ByteBuf 的可写字节数，但是同过自身的动态扩展可以满足新的写入请求，则进行动态扩展。
netty的ByteBuf可以动态扩展，为了保证安全性，允许使用者指定最大的容量，在容量范围内，可以先分配个较小的初始容量，后面不够再动态扩展，这样可以达到功能和性能的最优组合。
calculateNewCapacity 首先需要重新计算下扩展后的容量，它有一个参数，等于 writerIndex + minWritableBytes ,也就是满足要求的最小容量。
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. 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); }
首先设置门限阈值为4M，当需要的新容量正好等于门限阈值，则使用阈值作为新的缓冲去容量。如果新申请的内存空间大于阈值，不能采用倍增的方式（防止内存膨胀和浪费）扩张内存，采用每次4M的方式进行内存扩张。扩张的时候需要对扩张后的内存和最大内存（maxCapacity） 进行比较，如果大于缓冲区的最大长度，则使用maxCapacity 作为扩容后的缓冲区容量。
如果扩容后的新容量小于阈值，则以64为计数进行倍增，直到倍增后的结果大于或等于需要的容量值。
采用倍增或者步进算法的原因：如果以 minNewCapacity 作为目标容量，则本次扩容的可写字节数刚好够本次写入使用。写入完成后，它的可写字节数会变为0，下次做写入操作的时候，需要再次动态扩张。这样会形成第一次动态扩张后，每一次写入操作都会进行动态扩张，由于动态扩张需要进行内存复制，频繁的内存复制会导致性能下降。
采用先倍增后步进的原因：当内存比较小的情况下，倍增操作并不会带来太多的内存浪费，例如64字节-->128字节-->256字节，这样的内存扩张方式对于大多数应用系统是可以接受的。但是当内存增长到一定阈值后，再进行倍增就可能会带来额外的内存浪费，例如10M，采用倍增后变为20M，很有可能系统只需要12M，扩张到20M后会带来8M内存的浪费。由于每个客户端连接都可能维护自己独立的接受和发送缓冲区，这样随着客户端的线性增长，内存浪费也会比例的增加，因此，达到某个阈值后就需要以步进的方式对内存进行平滑的扩张。
这个阈值是个经验值，不同的应用场景，这个值可能不同，此处，ByteBuf取值为4M。
重新计算完成动态扩张后的目标容量后，需要重新创建个新的缓冲区，将原缓冲区的内容复制到新创建的ByteBuf中，最后设置读写索引和mark标签等。不同的子类会对应不同的复制操作，所以该方法依然是一个抽象方法，由子类复制实现。
/** * Adjusts the capacity of this buffer. If the {@code newCapacity} is less than the current * capacity, the content of this buffer is truncated. If the {@code newCapacity} is greater * than the current capacity, the buffer is appended with unspecified data whose length is * {@code (newCapacity - currentCapacity)}. */ public abstract ByteBuf capacity(int newCapacity);
操作索引
与索引相关的操作主要设计设置读写索引、mark和rest等
@Override public ByteBuf readerIndex(int readerIndex) { if (readerIndex < 0 || readerIndex > writerIndex) { throw new IndexOutOfBoundsException(String.format( "readerIndex: %d (expected: 0 <= readerIndex <= writerIndex(%d))", readerIndex, writerIndex)); } this.readerIndex = readerIndex; return this; }
在重新设置读索引之前需要对索引进行合法性判断，如果它小于0或者大于写索引，则抛出IndexOutOfBoundsException 异常，设置失败。校验通过之后，将索引设置为新的值，然后返回当前的ByteBuf对象。
重用缓冲区
@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; }
首先都对读索引进行判断，如果为0则说明没有可重用的缓冲区，直接返回。如果读索引大于0 且读索引不等于写索引，说明缓冲区中既有已经读取过的被丢弃的缓冲区，也有尚未读取的可读缓冲区。调用setBytes(0, this, readerIndex, writerIndex - readerIndex);方法进行字节数组复制。将尚未读取的字节数组复制到缓冲区的起始位置，然后重新设置读写索引，读索引设置为0，写索引设置为之前的写索引减去读索引（重用的缓冲区长度）。
在设置读写索引的同时，需要同时调整 markedReaderIndex 和 markedWriterIndex，调整mark的代码如下
protected final void adjustMarkers(int decrement) { int markedReaderIndex = this.markedReaderIndex; if (markedReaderIndex <= decrement) { this.markedReaderIndex = 0; int markedWriterIndex = this.markedWriterIndex; if (markedWriterIndex <= decrement) { this.markedWriterIndex = 0; } else { this.markedWriterIndex = markedWriterIndex - decrement; } } else { this.markedReaderIndex = markedReaderIndex - decrement; markedWriterIndex -= decrement; } }
首先对备份的markedReaderIndex和需要减少的decrement进行判断，如果小于需要的减少的值，则将markedReaderIndex设置为0，注意，无论markedReaderIndex 还是markedWriterIndex ，它的取值都不能小于0。如果markedWriterIndex也小于需要减少的值，则markedWriterIndex 设置为0，否则markedWriterIndex 减去decrement之后的值就是新的markedWriterIndex 。
如果需要减小的值小于 markedReaderIndex，则它也一定也小于markedWriterIndex ，markedReaderIndex 和markedWriterIndex 的新值就是减去decrement之后的取值。
如果readerIndex等于writerIndex,则说明没有可读的字节数组，那就不需要进行内存复制，直接调整mark，将读写索引设置为0即可完成缓冲区的重用.
else { adjustMarkers(readerIndex); writerIndex = readerIndex = 0; } // 没有可读的字节数组，不需要内存复制
skipBytes
在解码的时候，有时候需要丢弃非法的数据报，或者跳跃过不需要读取的字节或字节数组，此时使用skipBytes就非常方便。它可以忽略指定长度的字节数组，读操作时直接跳过这些数据读取后面的可读的缓冲区。
@Override public ByteBuf skipBytes(int length) { checkReadableBytes(length); int newReaderIndex = readerIndex + length; if (newReaderIndex > writerIndex) { throw new IndexOutOfBoundsException(String.format( "length: %d (expected: readerIndex(%d) + length <= writerIndex(%d))", length, readerIndex, writerIndex)); } readerIndex = newReaderIndex; return this; }
首先判断跳过的长度是否大于当前缓冲区可读的字节数组长度，如果大于可读字节数组长度，则抛出IndexOutOfBoundsException；如果参数本身为负数，则抛出IllegalArgumentException异常。
校验的源码：
/** * Throws an {@link IndexOutOfBoundsException} if the current * {@linkplain #readableBytes() readable bytes} of this buffer is less * than the specified value. */ protected final void checkReadableBytes(int minimumReadableBytes) { ensureAccessible(); if (minimumReadableBytes < 0) { throw new IllegalArgumentException("minimumReadableBytes: " + minimumReadableBytes + " (expected: >= 0)"); } if (readerIndex > writerIndex - minimumReadableBytes) { throw new IndexOutOfBoundsException(String.format( "readerIndex(%d) + length(%d) exceeds writerIndex(%d): %s", readerIndex, minimumReadableBytes, writerIndex, this)); } }
如果检验通过，则设置新的读索引为旧的索引值与跳跃的长度之和，然后对新的读索引进行判断，如果大于写索引，则抛出IndexOutOfBoundsException异常，如果合法，则读索引设置为新的读索引。这样后续的读操作的时候就会从新的读索引开始，跳过length个字节。