ByteBuf是顶层的抽象类,定义了用于传输数据的ByteBuf需要的方法和属性。
AbstractByteBuf
直接继承ByteBuf,一些公共属性和方法的公共逻辑会在这里定义。例如虽然不同性质的ByteBuf底层实现不同如堆Buffer和直接Buffer,但在进行数据写入的时候都要检查并移动readIndex,因此诸如检查并移动readIndex的方法就抽取并定义在AbstractByteBuf方法中。
公共成员变量
分为两大类,一是读写索引和mark索引,一个是leakDetector,用于检查是否存在内存泄露,该成员变量是static意味着所有ByteBuf的实例共享同一个leakDetector,单例设计模式处处可见。
static final ResourceLeakDetector<ByteBuf> leakDetector; int readerIndex; int writerIndex; private int markedReaderIndex; private int markedWriterIndex; private int maxCapacity;
读操作簇
以readBytes为例,在AbstractByteBuf里主要做了两件事情
- 合法性检查
- 调用getBytes,之所以用调用是因为getBytes会因为子类的不同实现而有所区别
- 索引移动
public ByteBuf readBytes(byte[] dst, int dstIndex, int length) { this.checkReadableBytes(length); this.getBytes(this.readerIndex, dst, dstIndex, length); this.readerIndex += length; return this; }
写操作簇
同样做了三件事情
- 合法性检查
- 调用setBytes
- 索引移动
public ByteBuf writeBytes(ByteBuf src, int srcIndex, int length) { this.ensureWritable(length); this.setBytes(this.writerIndex, src, srcIndex, length); this.writerIndex += length; return this; }
在ensureWritable中封装了扩容逻辑,这也是ByteBuf比NIO中的ByteBuffer优秀的地方。首先检查传入的length是否小于零,小于零则抛出异常,否则执行ensureWritable0,Netty给方法起的名字总是这么随意……
public ByteBuf ensureWritable(int minWritableBytes) { if (minWritableBytes < 0) { throw new IllegalArgumentException(String.format("minWritableBytes: %d (expected: >= 0)", minWritableBytes)); } else { this.ensureWritable0(minWritableBytes); return this; } }
- 如果当前期望写入的数据长度(minWritableByte)大于此时ByteBuf的长度(writableBytes)且大于剩余的最大容量(this.MaxCapacity-this.writerIndex),抛出异常。ByteBuf真的不能写了。
- 如果当前期望写入的数据长度(minWritableByte)大于此时ByteBuf的长度(writableBytes),但小于剩余的最大容量(this.MaxCapacity-this.writerIndex),调用calculateNewCapacity扩容,返回扩容后的大小(newCapacity),并重新设置当前ByteBuf(this.capacity(newCapacity))。
- 如果当前期望写入的数据长度(minWritableByte)小于此时ByteBuf的长度,啥也不干。
final void ensureWritable0(int minWritableBytes) { this.ensureAccessible(); if (minWritableBytes > this.writableBytes()) { if (minWritableBytes > this.maxCapacity - this.writerIndex) { throw new IndexOutOfBoundsException(String.format("writerIndex(%d) + minWritableBytes(%d) exceeds maxCapacity(%d): %s", this.writerIndex, minWritableBytes, this.maxCapacity, this)); } else { int newCapacity = this.alloc().calculateNewCapacity(this.writerIndex + minWritableBytes, this.maxCapacity); this.capacity(newCapacity); } } }
calculateNewCapacity传入两个参数:能够完成这里写入所需要的最小容量(minNewCapacity),当前支持的最大容量(maxCapacity)。
- 首先合法性检查,minNewCapacity<0或者minNewCapacity>maxCapacity抛出异常。
- 如果需要的容量等于4MB(minNewCapacity==4194304),那么把4MB作为扩容后的容量并返回。
- 如果需要的容量大于4MB,首先找到一个小于等于4MB整数倍的容量(newCapacity),如果newCapacity加上4MB大于maxCapacity则返回maxCapacity,否则返回newCapacity加4MB,保证扩容后的容量永远是4MB的整数倍,这种思想和HashMap扩容很接近,有人把这种扩容称为步进4MB扩容方式。
- 如果需要的容量小于4MB,从64开始倍增,直到大于等于需要的容量。
public int calculateNewCapacity(int minNewCapacity, int maxCapacity) { if (minNewCapacity < 0) { throw new IllegalArgumentException("minNewCapacity: " + minNewCapacity + " (expected: 0+)"); } else if (minNewCapacity > maxCapacity) { throw new IllegalArgumentException(String.format("minNewCapacity: %d (expected: not greater than maxCapacity(%d)", minNewCapacity, maxCapacity)); } else { int threshold = 4194304; if (minNewCapacity == 4194304) { return 4194304; } else { int newCapacity; if (minNewCapacity > 4194304) { newCapacity = minNewCapacity / 4194304 * 4194304; if (newCapacity > maxCapacity - 4194304) { newCapacity = maxCapacity; } else { newCapacity += 4194304; } return newCapacity; } else { for(newCapacity = 64; newCapacity < minNewCapacity; newCapacity <<= 1) { } return Math.min(newCapacity, maxCapacity); } } } }
这里应该还有一个复制的操作,但是在这个抽象类里没有找到,应该在具体的实现类中。
重用缓冲区
把已读的部分[0,readIndex]重用起来。
- 如果readIndex==0,没有可以重用的区域。
- 如果readIndex!=0且readIndex!=writeIndex,说明在0~readIndex区间内的内存可以重用,调用setBytes,把尚未读取的内容复制到缓冲区的开始,然后把writerIndex向前挪(this.writerIndex-=this.readerIndex),重设读索引为0。
- 如果readIndex!=0且readIndex==writeIndex,说明有可以重用的内存,且不存在还没有读取的数据,直接重设读写索引为0(readIndex=writeIndex=0)
public ByteBuf discardReadBytes() { this.ensureAccessible(); if (this.readerIndex == 0) { return this; } else { if (this.readerIndex != this.writerIndex) { this.setBytes(0, this, this.readerIndex, this.writerIndex - this.readerIndex); this.writerIndex -= this.readerIndex; this.adjustMarkers(this.readerIndex); this.readerIndex = 0; } else { this.adjustMarkers(this.readerIndex); this.writerIndex = this.readerIndex = 0; } return this; } }
AbstractReferenceCountedByteBuf
直接继承自AbstractByteBuf,添加了引用计数的功能,类似于JVM垃圾回收中的引用计数法,当一个ByteByf对象引用计数为1时,代表该ByteBuf没有有效引用,可以被回收。
属性
- refCntUpdater,一个Atomic的对象,使用refCntUpdater的CAS方法线程安全的修改refCnt,实现无锁化,提高效率。
- refCnt,volatile类型的变量,记录当前ByteBuf的引用次数。初始值为1,每次用新的引用增加1,失去一个引用减1,当最终再次回到1的时候释放ByteBuf
private static final AtomicIntegerFieldUpdater<AbstractReferenceCountedByteBuf> refCntUpdater = AtomicIntegerFieldUpdater.newUpdater(AbstractReferenceCountedByteBuf.class, "refCnt"); private volatile int refCnt = 1;
retain
每调用一次retain方法refCnt就会线程安全的增加一,retain主要调用了retain0方法,netty方法的名字还是这样随意。熟悉的JUC的味道,熟悉的for(;;)写法,做了两件事情。
- 合法性检查。nextCnt<=increment就会抛出异常,这里很有意思,分两个情况来看:nextCnt<increment,nextCnt=increment+refCnt,increment是一个大于零的数,只有在溢出的情况下nextCnt才会小于refCnt,所以小于号是来避免溢出的发生。nextCnt=increment,increment一定是大于零的,那么只有refCnt=0的时候才会发生nextCnt=increment,所以在netty看来refCnt=0是一个异常情况,这种异常情况只会发生在错误调用release的情况下才会发生。
- 自旋CAS修改refCnt。
private ByteBuf retain0(int increment) { for (;;) { int refCnt = this.refCnt; final int nextCnt = refCnt + increment; // Ensure we not resurrect (which means the refCnt was 0) and also that we encountered an overflow. if (nextCnt <= increment) { throw new IllegalReferenceCountException(refCnt, increment); } if (refCntUpdater.compareAndSet(this, refCnt, nextCnt)) { break; } } return this; }
release
每调用一次release,refCnt会线程安全的减少一,当减少到refCnt==decrement时,调用deallocate方法回收ByteBuf内存,deallocate需要由具体的子类重写。
private boolean release0(int decrement) { for (;;) { int refCnt = this.refCnt; if (refCnt < decrement) { throw new IllegalReferenceCountException(refCnt, -decrement); } if (refCntUpdater.compareAndSet(this, refCnt, refCnt - decrement)) { if (refCnt == decrement) { deallocate(); return true; } return false; } } }
UnpooledHeapByteBuf
- unpooled,非池化,每次使用ByteBuf都需要新申请一个ByteBuf,相较于Pooled效率较低,但使用起来较为简单。
- Heap,分配在堆上。
属性
- alloc,聚合了一个ByteBufAllocator,用于分配内存。
- array,缓冲区。
- tmpNioBuf,用于实现ByteBuf到NIO中的ByteBuffer转换。
private final ByteBufAllocator alloc; byte[] array; private ByteBuffer tmpNioBuf;
capacity
用于调整ByteBuf的长度到指定长度,与写方法簇中的动态调整不同,后者的调用对使用者是透明的,而用户可以主动的调用capacity方法调整长度。如果newCapacity>oldCapacity,那么就在ByteBuf里添加一unspecified数据,如果newCapacity<oldCapacity那么从ByteBuf里删除一些数据。
- 如果newCapacity>oldCapacity,分配一个新的byte数组(allocateArray),把旧的数组复制过去(arraycopy),让属性中的arr指向新的数组,释放就的数组对象。
- 如果newCapacity<oldCapacity,需要截取。如果readIndex<newCapacity<writeCapacity,则把writeIndex设置为新的容量。如果newCapacity<readerIndex,说明没有可读的字节数组需要复制。
public ByteBuf capacity(int newCapacity) { checkNewCapacity(newCapacity); int oldCapacity = array.length; byte[] oldArray = array; if (newCapacity > oldCapacity) { byte[] newArray = allocateArray(newCapacity); System.arraycopy(oldArray, 0, newArray, 0, oldArray.length); setArray(newArray); freeArray(oldArray); } else if (newCapacity < oldCapacity) { byte[] newArray = allocateArray(newCapacity); int readerIndex = readerIndex(); if (readerIndex < newCapacity) { int writerIndex = writerIndex(); if (writerIndex > newCapacity) { writerIndex(writerIndex = newCapacity); } System.arraycopy(oldArray, readerIndex, newArray, readerIndex, writerIndex - readerIndex); } else { setIndex(newCapacity, newCapacity); } setArray(newArray); freeArray(oldArray); } return this; }