Netty之Unpooled_Bytebuf
前言
计算机存储基本单位是字节(byte),传输基本单位是bit(位),JAVA NIO提供了ByteBuffer等七种容器来提升传输时的效率,但是在使用时比较复杂,经常要进行读写切换,主要缺点如下:
（1）ByteBuffer长度固定，一旦分配完成，它的容量不能动态扩展和收缩，当需要编码的对象大于ByteBuffer的容量时，会发生索引越界异常；
（2）ByteBuffer只有一个标识位置的指针position，读写的时候需要手工调用flip()和rewind()等，使用者必须小心谨慎地处理这些API，否则很容易导致程序处理失败；
（3）ByteBuffer的API功能有限，一些高级和实用的特性它不支持，需要使用者自己编程实现。
为了弥补这些不足，Netty提供了自己的ByteBuffer实现—— ByteBuf。
ByteBuf介绍
ByteBuf是Netty.Buffer中的类,主要特征如下:
- 读和写用不同的索引。
- 读和写可以随意的切换，不需要调用flip()方法。
- 容量能够被动态扩展，和StringBuilder一样。
- 用其内置的复合缓冲区可实现透明的零拷贝。
- 支持方法链。
- 支持引用计数。count == 0,release。
- 支持池。
ByteBuf通过两个位置指针来协助缓冲区的读写操作，分别是读操作(使用readerIndex)、写操作(使用writerIndex)。
readerIndex和writerIndex的取值一开始都是0，随着数据的写入writerIndex会增加，读取数据会使readerIndex增加，但是它不会超过writerIndex。在读取之后，0～readerIndex的就被视为discard的，调discardReadBytes方法，可以释放这部分空间，它的作用类似ByteBuffer的compact方法。readerIndex和writerIndex之间的数据是可读取的，等价于ByteBuffer position和limit之间的数据。writerIndex和capacity之间的空间是可写的，等价于ByteBuffer limit和capacity之间的可用空间。
由于写操作不修改readerIndex指针，读操作不修改writerIndex指针，因此读写之间不再需要调整位置指针，这极大地简化了缓冲区的读写操作，避免了由于遗漏或者不熟悉flip()操作导致的功能异常。
传统JAVA NIO ByteBuffer图示:
ByteBuf读写示意图:
ByteBuf零拷贝
netty提供了CompositeByteBuf类实现零拷贝。大多数情况下，在进行网络数据传输时我们会将消息分为消息头head和消息体body，甚至还会有其他部分，这里我们简单的分为两部分来进行探讨：
以前的做法
ByteBuffer header = ByteBuffer.allocate(1);
header.put("a".getBytes());
header.flip();
ByteBuffer body = ByteBuffer.allocate(1);
body.put("b".getBytes());
body.flip(); ByteBuffer message = ByteBuffer.allocate(header.remaining() + body.remaining()); message.put(header);
message.put(body);
message.flip();
while (message.hasRemaining()){
System.err.println((char)message.get());
}
这样为了得到完整的消息体相当于对内存进行了多余的两次拷贝，造成了很大的资源的浪费。
netty提供的方法
CompositeByteBuf messageBuf = Unpooled.compositeBuffer();
ByteBuf headerBuf = Unpooled.buffer(1);
headerBuf.writeByte('a');
ByteBuf bodyBuf = Unpooled.buffer(1);
bodyBuf.writeByte('b');
messageBuf.addComponents(headerBuf, bodyBuf);
for (ByteBuf buf : messageBuf) {
System.out.println((char)buf.readByte());
System.out.println(buf.toString());10
}
这里通过CompositeByteBuf 对象将headerBuf 与bodyBuf组合到了一起，也得到了完整的消息体，但是并未进行内存上的拷贝。可以注意下我在上面代码段中进行的buf.toString()方法的调用，得出来的结果是:指向的还是原来分配的空间地址，也就证明了零拷贝的观点。
ByteBuf引用计数
retain和lock类似，release和unlock类似，内部维护一个计数器，计数器到0的时候就表示已经释放掉了。往一个已经被release掉的buffer中去写数据，会抛出IllegalReferenceCountException: refCnt: 0异常。
ByteBuf buffer = Unpooled.buffer(1);
int i = buffer.refCnt();
System.err.println("refCnt : " + i); //refCnt : 1
buffer.retain();
buffer.retain();
buffer.retain();
buffer.retain();
i = buffer.refCnt();
System.err.println("refCnt : " + i); //refCnt : 5
boolean release = buffer.release();
i = buffer.refCnt();
System.err.println("refCnt : " + i + " ===== " + release); //refCnt : 4 ===== false
release = buffer.release(4);
i = buffer.refCnt();
System.err.println("refCnt : " + i + " ===== " + release); //refCnt : 0 ===== true
引用计数器实现的原理并不复杂，仅仅只是涉及到一个指定对象的活动引用，对象被初始化后引用计数值为1。只要引用计数大于0，这个对象就不会被释放，当引用计数减到为0时，这个实例就会被释放，被释放的对象不应该再被使用。
ByteBuf支持池
Netty对ByteBuf的分配提供了池支持，具体的类是PooledByteBufAllocator。用这个分配器去分配ByteBuf可以提升性能以及减少内存碎片。Netty中默认用PooledByteBufAllocator当做ByteBuf的分配器。PooledByteBufAllocator对象可以从Channel中或者绑定了Channel的ChannelHandlerContext中去获取到。
Channel channel = ...;
ByteBufAllocator allocator = channel.alloc();
....
ChannelHandlerContext ctx = ...;
ByteBufAllocator allocator2 = ctx.alloc();
ByteBuf API介绍
创建ByteBuf
// 创建一个heapBuffer，是在堆内分配的
ByteBuf heapBuf = Unpooled.buffer(5);
if (heapBuf.hasArray()) {
byte[] array = heapBuf.array();
int offset = heapBuf.arrayOffset() + heapBuf.readerIndex();
int length = heapBuf.readableBytes();
handleArray(array, offset, length);
}
// 创建一个directBuffer,是分配的堆外内存
ByteBuf directBuf = Unpooled.directBuffer();
if (!directBuf.hasArray()) {
int length = directBuf.readableBytes();
byte[] array = new byte[length];
directBuf.getBytes(directBuf.readerIndex(), array);
handleArray(array, 0, length);
}
这两者的主要区别：
a. 分配的堆外内存空间，在进行网络传输时就不用进行拷贝，直接被网卡使用。但是这些空间想要被jvm所使用，必须拷贝到堆内存中。
b. 分配和释放堆外内存相比堆内存而言，代价是相当昂贵的。
c. 使用这两者buffer中的数据的方式也略有不同,见上面的代码段。
读写数据（readByte writeByte）
ByteBuf heapBuf = Unpooled.buffer(5);
heapBuf.writeByte(1);
System.err.println("writeIndex : " + heapBuf.writerIndex());//writeIndex : 1
heapBuf.readByte();
System.err.println("readIndex : " + heapBuf.readerIndex());//readIndex : 1
heapBuf.setByte(2, 2);
System.err.println("writeIndex : " + heapBuf.writerIndex());//writeIndex : 1
heapBuf.getByte(2);
System.err.println("readIndex : " + heapBuf.readerIndex());//readIndex : 1
进行readByte和writeByte方法的调用时会改变readIndex和writeIndex的值，而调用set和get方法时不会改变readIndex和writeIndex的值。上面的测试案例中打印的writeIndex和readIndex均为1,并未在调用set和get方法后被改变。
discardReadBytes方法
先看一张图：
从上面的图中可以观察到，调用discardReadBytes方法后，readIndex置为0，writeIndex也往前移动了Discardable bytes长度的距离，扩大了可写区域。但是这种做法会严重影响效率，它进行了大量的拷贝工作。如果要进行数据的清除操作，建议使用clear方法。调用clear()方法将会将readIndex和writeIndex同时置为0，不会进行内存的拷贝工作，同时要注意，clear方法不会清除内存中的内容,只是改变了索引位置而已。
Derived buffers
这里介绍三个方法（浅拷贝）：
duplicate()：直接拷贝整个buffer。
slice()：拷贝buffer中已经写了的数据。
slice(index,length): 拷贝buffer中从index开始，长度为length的数据。
readSlice(length): 从当前readIndex读取length长度的数据。
上面这几个方法的虽然是拷贝，但是这几个方法并没有实际意义上去复制一个新的buffer出来，它和原buffer是共享数据的。所以说调用这些方法消耗是很低的，并没有开辟新的空间去存储，但是修改后会影响原buffer。这种方法也就是咱们俗称的浅拷贝。
要想进行深拷贝，这里可以调用copy()和copy(index,length)方法，使用方法和上面介绍的一致，但是会进行内存复制工作，效率很低。
ByteBuf heapBuf = Unpooled.buffer(5);
heapBuf.writeByte(1);
heapBuf.writeByte(1);
heapBuf.writeByte(1);
heapBuf.writeByte(1);
// 直接拷贝整个buffer
ByteBuf duplicate = heapBuf.duplicate();
duplicate.setByte(0, 2);
System.err.println("duplicate: " + duplicate.getByte(0) + "====heapBuf: " + heapBuf.getByte(0));//duplicate: 2====heapBuf: 2
// 拷贝buffer中已经写了的数据
ByteBuf slice = heapBuf.slice();
System.err.println("slice capacity: " + slice.capacity());//slice capacity: 4
slice.setByte(2, 5);
ByteBuf slice1 = heapBuf.slice(0, 3);
System.err.println("slice1 capacity: "+slice1.capacity());//slice1 capacity: 3
System.err.println("duplicate: " + duplicate.getByte(2) + "====heapBuf: " + heapBuf.getByte(2));//duplicate: 5====heapBuf: 5复制代码
