转载

初始Netty原理 (二)

上文已经了解到了Netty中的启动器、反应器、通道、处理器、流水线，下面来了解一下Netty中较为重要的ByteBuf缓冲区。

概念

优势

Pooling池化，减少了内存复制和GC，提升了效率。
读写分开存储，索引也分开了，不需要切换读写模式。
方法可链式调用，引入了引用计数法，方便了池化与内存回收。

重要属性

readerIndex(读指针)：读取的起始位置，每读取一个字节，就加1，当它等于writerIndex时，说明已经读完了。
writerIndex(写指针)：写入的起始位置，每写入一个字节，就加1，当它等于capacity()时，说明当前容量满了。此时可扩容，如果不能继续扩容，则不能写了。
maxCapacity(最大容量)：可以扩容的最大容量，当前容量等于这个值时，说明不能再扩容了。

引用计数

Netty采用“计数器”来追踪ByteBuf的生命周期，主要是用于对池化的支持。（池化就是当ByteBuf的引用为0时，就会放到对象缓存池中，当需要用缓冲区时，可以直接从这个池里面取出来用，而不用重新创建一个了）。通过源码可以发现ByteBuf实现了一个类ReferenceCounted。这个类就是用于引用计数的。

当创建完ByteBuf时，引用数为1，通过refCnt()方法可以获取当前缓冲区的引用数，调用retain()方法可以使引用数加1，调用release()方法可以使引用数减1，当引用数为0时，缓冲区就会被完全释放。如果池化了就放到缓冲池中。如果没池化就分两种情况，如果是分配在堆内存上的，就通过JVM的垃圾回收机制把它回收，如果分配在堆外直接内存上，就通过本地方法来释放堆外内存。在Handler处理器中，Netty会自动给流水线在最后加一个处理器用来调用release()去释放缓冲区，如果要在中间中断流水线，则需要自己调用release()释放缓冲区。

Allocator分配器

Netty提供了ByteAllocator的两种实现：PoolByteAllocator（池化）和UnpooledByteAllocator(未池化)。Netty默认使用的是PoolByteAllocator，默认使用的内存是堆外直接内存（写入速度比堆内存更快，池化分配器配合堆外直接内存，可将堆外缓冲区复用（弥补了堆外分配和释放空间的代价较高的缺点），从来大大提升了性能）。

浅层复制

浅层复制有两个方法，切片浅层复制和整体浅层复制

slice切片浅层复制 ：切片只复制了原缓冲区的可读部分，不会复制底层数组（引用同一个），也不会增加引用数。
duplicate整体浅层复制 ：这个是将整体都复制了，可读可写，但是引用还是一样的（同slice）。

实践

来写个小例子，分析一下。这里的Logger使用的是自己封装的静态日志类。分析堆栈信息封装一个SLF4J的静态类

public class testBuffer {

	public static void main(String[] args) {
		// 默认使用池化缓冲区，分配的是堆外直接内存
		ByteBuf buf = ByteBufAllocator.DEFAULT.buffer(9, 100);
		// 使用堆内存来分配缓冲区内存
		ByteBuf buf1 = ByteBufAllocator.DEFAULT.heapBuffer(9, 100);
		// 写入一个字节数组
		buf.writeBytes(new byte[] { 1, 2, 3, 4 });
		Logger.info("引用次数--[{}]", buf.refCnt());
		// 依次读出来
		int i = 0;
		while (buf.isReadable() && i < buf.readableBytes()) {
			// 读字节，不改变指针(读完后，readIndex还是0)
			Logger.info("取一个字节--[{}]", buf.getByte(i++));
		}
		Logger.info("buf是否使用的堆内存--[{}]", buf.hasArray());
		Logger.info("buf1是否使用的堆内存--[{}]", buf1.hasArray());
		int len = buf.readableBytes();
		byte[] array = new byte[len];
		// 把数据读取到堆内存中
		buf.getBytes(buf.readerIndex(), array);
		Logger.info("buf读出的数据--[{}]", array);
		// 与原缓冲区buf的底层引用一样
		ByteBuf slice = buf.slice();
        // 增加一次浅层复制的引用
		slice.retain();
        // 减少一次原缓冲区的引用
		buf.release();
        // 会发现两个引用是同一个
		Logger.info("引用次数--[{}]", buf.refCnt());
		Logger.info("切片结果--{}", slice);
		Logger.info("引用次数--[{}]", slice.refCnt());
	}
}
复制代码

运行结果：

21:02:59.693 [main] INFO byteBuf.test1 - 引用次数--[1]
21:02:59.695 [main] INFO byteBuf.test1 - 取一个字节--[1]
21:02:59.696 [main] INFO byteBuf.test1 - 取一个字节--[2]
21:02:59.696 [main] INFO byteBuf.test1 - 取一个字节--[3]
21:02:59.696 [main] INFO byteBuf.test1 - 取一个字节--[4]
21:02:59.696 [main] INFO byteBuf.test1 - buf是否使用的堆内存--[false]
21:02:59.696 [main] INFO byteBuf.test1 - buf1是否使用的堆内存--[true]
21:02:59.696 [main] INFO byteBuf.test1 - buf读出的数据--[[1, 2, 3, 4]]
21:02:59.698 [main] INFO byteBuf.test1 - 引用次数--[1]
21:02:59.698 [main] INFO byteBuf.test1 - 切片结果--UnpooledSlicedByteBuf(ridx: 0, widx: 4, cap: 4/4, unwrapped: PooledUnsafeDirectByteBuf(ridx: 0, widx: 4, cap: 9/100))
21:02:59.698 [main] INFO byteBuf.test1 - 引用次数--[1]
复制代码

原文 https://juejin.im/post/5df84c2ce51d4558042565de

正文到此结束