文章目录
一、EventLoop
1. 概述
事件循环对象 EventLoop
EventLoop 本质是一个单线程执行器（同时维护了一个 Selector），里面有 run 方法处理一个或多个 Channel 上源源不断的 io 事件
它的继承关系如下
- 继承自 j.u.c.ScheduledExecutorService 因此包含了线程池中所有的方法
- 继承自 netty 自己的 OrderedEventExecutor
- 提供了 boolean inEventLoop(Thread thread) 方法判断一个线程是否属于此 EventLoop
- 提供了 EventLoopGroup parent() 方法来看看自己属于哪个 EventLoopGroup
事件循环组 EventLoopGroup
EventLoopGroup 是一组 EventLoop，Channel 一般会调用 EventLoopGroup 的 register 方法来绑定其中一个 EventLoop，后续这个 Channel 上的 io 事件都由此 EventLoop 来处理（保证了 io 事件处理时的线程安全）
- 继承自 netty 自己的 EventExecutorGroup
- 实现了 Iterable 接口提供遍历 EventLoop 的能力
- 另有 next 方法获取集合中下一个 EventLoop
2. 处理普通任务以及定时任务
示例
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.TimeUnit;
/**
* @Description: 测试EventLoop执行普通任务以及定时任务
* @Author: Aiguodala
* @CreateDate: 2021/5/10 19:19
*/
@Slf4j
public class TestEventLoopCommonTask {
public static void main(String[] args) {
// 创建一个拥有两个线程的NioEventLoopGroup
EventLoopGroup group = new NioEventLoopGroup(2);
// 可以通过group.next() 方法获取下一个EventLoop对象，
// 这里可以发现就只有 设置的两个线程
System.out.println(group.next());
System.out.println(group.next());
System.out.println(group.next());
System.out.println(group.next());
// 通过线程池的execute()方法 或者submit() 方法执行普通任务
group.next().execute(() -> {
log.debug("执行普通任务");
});
// Runnable command, long initialDelay, long delay, TimeUnit unit
// 通过scheduleAtFixedRate()方法执行定时任务
// 第一个参数是Runnable(需要执行的任务)，
// 第二个参数是执行的延迟时间，就是过多久以后开始执行
// 第三、四个参数是每过多久执行一次以及时间单位
group.next().scheduleAtFixedRate(() -> {
log.debug("执行定时任务");
}, 0, 1, TimeUnit.SECONDS);
// 关闭该时间循环组
// group.shutdownGracefully();
}
}
关闭 EventLoopGroup
优雅关闭 shutdownGracefully 方法。该方法会首先切换 EventLoopGroup 到关闭状态从而拒绝新的任务的加入，然后在任务队列的任务都处理完成后，停止线程的运行。从而确保整体应用是在正常有序的状态下退出的
3. 处理 I / O 任务
示例
- 服务端
/**
* @Description:
* @Author: Aiguodala
* @CreateDate: 2021/5/10 19:35
*/
@Slf4j
public class EventLoopServer {
public static void main(String[] args) {
new ServerBootstrap()
// group()方法可以传入两个EventLoopGroup参数，分别负责处理不同的事件
// 例如一个作为 Acceptor 处理连接事件， 一个作为Handler 处理读写事件
.group(new NioEventLoopGroup(1), new NioEventLoopGroup(2))
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<NioSocketChannel>() {
@Override
protected void initChannel(NioSocketChannel ch) throws Exception {
ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ByteBuf byteBuf = (ByteBuf) msg;
log.debug(byteBuf.toString(Charset.defaultCharset()));
}
});
}
})
.bind(8080);
}
}
- 客户端
/**
* @Description:
* @Author: Aiguodala
* @CreateDate: 2021/5/10 14:33
*/
public class EventLoopClient {
public static void main(String[] args) throws InterruptedException {
Channel channel = new Bootstrap()
.group(new NioEventLoopGroup())
.channel(NioSocketChannel.class)
.handler(new ChannelInitializer<Channel>() {
@Override
protected void initChannel(Channel channel) throws Exception {
channel.pipeline().addLast(new StringEncoder());
}
})
.connect(new InetSocketAddress("localhost", 8080))
.sync()
.channel();
Scanner scan = new Scanner(System.in);
while (true) {
String s = scan.nextLine();
channel.writeAndFlush(s);
}
}
}
设想如果一个IO任务的执行时间过长，这样会导致独占一个线程很久，影响其他channel的IO操作，所以此时可以使用非NioEventLoopGroup，避免同一个NioEventLoop中的其他Channel在较长的时间内都无法得到处理
示例：
/**
* @Description:
* @Author: Aiguodala
* @CreateDate: 2021/5/10 19:35
*/
@Slf4j
public class EventLoopServer {
public static void main(String[] args) {
// 创建DefaultEventLoopGroup来执行耗时很长的任务
EventLoopGroup group = new DefaultEventLoopGroup();
new ServerBootstrap()
.group(new NioEventLoopGroup(1), new NioEventLoopGroup(2))
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<NioSocketChannel>() {
@Override
protected void initChannel(NioSocketChannel socketChannel) throws Exception {
// 增加两个handler，第一个使用NioEventLoopGroup处理，第二个使用自定义EventLoopGroup处理
socketChannel.pipeline().addLast("nioHandler", new ChannelInboundHandlerAdapter() {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ByteBuf buf = (ByteBuf) msg;
log.debug(buf.toString(Charset.defaultCharset()));
// 调用下一个handler,用于Handler的传递
ctx.fireChannelRead(msg);
}
})
// 该handler绑定自定义的Group，第一个参数为处理任务的handler
.addLast(group, "myHandler", new ChannelInboundHandlerAdapter() {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ByteBuf buf = (ByteBuf) msg;
log.debug(buf.toString(Charset.defaultCharset()));
}
});
}
})
.bind(8080);
}
}
切换Handler是如何实现的？
static void invokeChannelRead(final AbstractChannelHandlerContext next, Object msg) {
final Object m = next.pipeline.touch(ObjectUtil.checkNotNull(msg, "msg"), next);
// 获取下一个EventLoop
EventExecutor executor = next.executor();
// 如果下一个EventLoop 在当前的 EventLoopGroup中，则直接调用
if (executor.inEventLoop()) {
next.invokeChannelRead(m);
} else {
// 否则让另一个 EventLoopGroup 中的 EventLoop 来创建任务并执行
executor.execute(new Runnable() {
@Override
public void run() {
next.invokeChannelRead(m);
}
});
}
}
二、Channel
Channel 的常用方法
- close() 可以用来关闭Channel
- closeFuture() 用来处理 Channel 的关闭
- sync 方法作用是同步等待 Channel 关闭
- 而 addListener 方法是异步等待 Channel 关闭
- pipeline() 方法用于添加处理器
- write() 方法将数据写入
- 因为缓冲机制，数据被写入到 Channel 中以后，不会立即被发送
- 只有当缓冲满了或者调用了flush()方法后，才会将数据通过 Channel 发送出去
- writeAndFlush() 方法将数据写入并立即发送（刷出）
1. ChannelFuture
处理连接问题
/**
* @Description:
* @Author: Aiguodala
* @CreateDate: 2021/5/10 14:33
*/
public class EventLoopClient {
public static void main(String[] args) throws IOException, InterruptedException {
ChannelFuture channelFuture = new Bootstrap()
.group(new NioEventLoopGroup())
.channel(NioSocketChannel.class)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
socketChannel.pipeline().addLast(new StringEncoder());
}
})
// 该方法为异步非阻塞方法，主线程调用后不会被阻塞，真正去执行连接操作的是NIO线程
// NIO线程：NioEventLoop 中的线程
.connect(new InetSocketAddress("localhost", 8080));
// 该方法用于等待连接真正建立
channelFuture.sync();
// 获取客户端-服务器之间的Channel对象
Channel channel = channelFuture.channel();
channel.writeAndFlush("hello world");
System.in.read();
}
}
如果我们去掉channelFuture.sync()方法，会服务器无法收到hello world
这是因为建立连接(connect)的过程是异步非阻塞的，若不通过sync()方法阻塞主线程，在连接真正建立之前，通过 channelFuture.channel() 拿到的 Channel 对象，并不是真正与服务器建立好连接的 Channel，也就没法将信息正确的传输给服务器端
所以需要通过channelFuture.sync()方法，阻塞主线程，同步处理结果，等待连接真正建立好以后，再去获得 Channel 传递数据。使用该方法，获取 Channel 和发送数据的线程都是主线程
下面还有一种方法，用于异步获取建立连接后的 Channel 和发送数据，使得执行这些操作的线程是 NIO 线程（去执行connect操作的线程）
addListener方法
通过这种方法可以在NIO线程中获取 Channel 并发送数据，而不是在主线程中执行这些操作
/**
* @Description:
* @Author: Aiguodala
* @CreateDate: 2021/5/10 14:33
*/
@Slf4j
public class EventLoopClient {
public static void main(String[] args) throws IOException, InterruptedException {
ChannelFuture channelFuture = new Bootstrap()
.group(new NioEventLoopGroup())
.channel(NioSocketChannel.class)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
socketChannel.pipeline().addLast(new StringEncoder());
}
})
// 该方法为异步非阻塞方法，主线程调用后不会被阻塞，真正去执行连接操作的是NIO线程
// NIO线程：NioEventLoop 中的线程
.connect(new InetSocketAddress("localhost", 8080));
// 增加监听器，在连接建立之后，异步回调operationComplete方法
channelFuture.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
Channel channel = channelFuture.channel();
channel.writeAndFlush("hello world");
}
});
}
}
处理关闭问题
示例
/**
* @Description:
* @Author: Aiguodala
* @CreateDate: 2021/5/10 14:33
*/
@Slf4j
public class EventLoopClient {
public static void main(String[] args) throws InterruptedException {
// 创建EventLoopGroup，使用完毕后关闭
NioEventLoopGroup group = new NioEventLoopGroup();
ChannelFuture channelFuture = new Bootstrap()
.group(group)
.channel(NioSocketChannel.class)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
socketChannel.pipeline().addLast(new StringEncoder());
}
})
.connect(new InetSocketAddress("localhost", 8080));
channelFuture.sync();
Channel channel = channelFuture.channel();
Scanner scanner = new Scanner(System.in);
// 创建一个线程用于输入并向服务器发送
new Thread(()->{
while (true) {
String msg = scanner.next();
if ("q".equals(msg)) {
// 关闭操作是异步的，在NIO线程中执行
channel.close();
break;
}
channel.writeAndFlush(msg);
}
}, "inputThread").start();
// 获得closeFuture对象
ChannelFuture closeFuture = channel.closeFuture();
log.debug("waiting close...");
// 同步等待NIO线程执行完close操作
closeFuture.sync();
// 关闭之后执行一些操作，可以保证执行的操作一定是在channel关闭以后执行的
log.debug("处理关闭之后的操作...");
// 关闭EventLoopGroup
group.shutdownGracefully();
}
}
当我们要关闭channel时，可以调用channel.close()方法进行关闭。但是该方法也是一个异步方法。真正的关闭操作并不是在调用该方法的线程中执行的，而是在NIO线程中执行真正的关闭操作
如果我们想在channel真正关闭以后，执行一些额外的操作，可以选择以下两种方法来实现
- 通过channel.closeFuture()方法获得对应的ChannelFuture对象，然后调用sync()方法阻塞执行操作的线程，等待channel真正关闭后，再执行其他操作
// 获得closeFuture对象
ChannelFuture closeFuture = channel.closeFuture();
// 同步等待NIO线程执行完close操作
closeFuture.sync();
- 调用closeFuture.addListener方法，添加close的后续操作
closeFuture.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture channelFuture) throws Exception {
// 等待channel关闭后才执行的操作
System.out.println("关闭之后执行一些额外操作...");
// 关闭EventLoopGroup
group.shutdownGracefully();
}
});
四、Future与Promise
1. 概述
netty 中的 Future 与 jdk 中的 Future 同名，但是是两个接口
netty 的 Future 继承自 jdk 的 Future，而 Promise 又对 netty Future 进行了扩展
- jdk Future 只能同步等待任务结束（或成功、或失败）才能得到结果
- netty Future 可以同步等待任务结束得到结果，也可以异步方式得到结果，但都是要等任务结束
- netty Promise 不仅有 netty Future 的功能，而且脱离了任务独立存在，只作为两个线程间传递结果的容器
JDK Future
/**
* @Description:
* @Author: Aiguodala
* @CreateDate: 2021/5/11 22:44
*/
@Slf4j
public class JdkFutureTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService service = Executors.newFixedThreadPool(2);
Future<Integer> future = service.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
log.debug("执行任务");
TimeUnit.SECONDS.sleep(1);
return 100;
}
});
// 阻塞等待获取结果
log.debug("获取结果{}", future.get());
}
}
Netty Future
/**
* @Description:
* @Author: Aiguodala
* @CreateDate: 2021/5/11 22:52
*/
@Slf4j
public class NettyFutureTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
EventLoopGroup group = new NioEventLoopGroup(2);
Future<Integer> future = group.next().submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
log.debug("执行任务");
TimeUnit.SECONDS.sleep(2);
return 100;
}
});
//立刻获得结果，如果未产生结果则返回null
log.debug("getNow{}", future.getNow());
//阻塞获取
log.debug("get{}", future.get());
// NIO线程中异步获取结果
future.addListener(new GenericFutureListener<Future<? super Integer>>() {
@Override
public void operationComplete(Future<? super Integer> future) throws Exception {
log.debug("获取结果{}", future.getNow());
}
});
}
}
Netty中的Future对象，可以通过EventLoop的sumbit()方法得到
- 可以通过Future对象的get方法，阻塞地获取返回结果
- 也可以通过getNow方法，获取结果，若还没有结果，则返回null，该方法是非阻塞的
- 还可以通过future.addListener方法，在Callable方法执行的线程中，异步获取返回结果
Netty Promise
Promise相当于一个容器，可以用于存放各个线程中的结果，然后让其他线程去获取该结果
/**
* @Description:
* @Author: Aiguodala
* @CreateDate: 2021/5/11 23:02
*/
@Slf4j
public class NettyPromiseTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
EventLoop eventLoop = new NioEventLoopGroup().next();
DefaultPromise<Integer> promise = new DefaultPromise<>(eventLoop);
new Thread(() -> {
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 存放结果
promise.setSuccess(100);
}).start();
log.debug("getNow获取结果: {}", promise.getNow());
log.debug("get获取结果: {}", promise.get());
promise.addListener(new GenericFutureListener<Future<? super Integer>>() {
@Override
public void operationComplete(Future<? super Integer> future) throws Exception {
log.debug("异步获取结果: {}", promise.get());
}
});
}
}
五、Handler与Pipeline
1. Pipeline
/**
* @Description:
* @Author: Aiguodala
* @CreateDate: 2021/5/11 23:35
*/
@Slf4j
public class PipelineTest {
public static void main(String[] args) {
new ServerBootstrap()
.group(new NioEventLoopGroup())
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<NioSocketChannel>() {
@Override
protected void initChannel(NioSocketChannel ch) throws Exception {
/**
* 在socketChannel的pipeline中添加handler
* pipeline中handler是带有head与tail节点的双向链表，的实际结构为 head <-> handler1 <-> ... <-> handler4 <->tail
* Inbound主要处理入站操作，一般为读操作，发生入站操作时会触发Inbound方法 入站时，handler是从head向后调用的
*/
ch.pipeline().addLast("handler1",new ChannelInboundHandlerAdapter(){
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
log.debug("handler 1 处理读任务");
super.channelRead(ctx, msg);
}
});
ch.pipeline().addLast("handler2",new ChannelInboundHandlerAdapter(){
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
log.debug("handler 2 处理读任务");
ch.writeAndFlush(ctx.alloc().buffer().writeBytes("Server...".getBytes(StandardCharsets.UTF_8)));
super.channelRead(ctx, msg);
}
});
ch.pipeline().addBefore("handler2", "before handler 2 ",new ChannelInboundHandlerAdapter(){
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
log.debug("before handler 2 处理读任务");
super.channelRead(ctx, msg);
}
});
/**
* Outbound主要处理出站操作，一般为写操作，发生出站操作时会触发Outbound方法
* 出站时，handler的调用是从tail向前调用的
*/
ch.pipeline().addLast("handler3", new ChannelOutboundHandlerAdapter() {
@Override
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
log.debug("handler 3 处理写任务");
super.write(ctx, msg, promise);
}
});
ch.pipeline().addLast("handler4", new ChannelOutboundHandlerAdapter() {
@Override
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
log.debug("handler 4 处理写任务");
super.write(ctx, msg, promise);
}
});
}
}).bind(8080);
}
}
运行结果如下
23:45:21.790 [nioEventLoopGroup-2-2] DEBUG com.lboyang.chapter02.PipelineTest - handler 1 处理读任务
23:45:21.790 [nioEventLoopGroup-2-2] DEBUG com.lboyang.chapter02.PipelineTest - before handler 2 处理读任务
23:45:21.790 [nioEventLoopGroup-2-2] DEBUG com.lboyang.chapter02.PipelineTest - handler 2 处理读任务
23:45:21.792 [nioEventLoopGroup-2-2] DEBUG com.lboyang.chapter02.PipelineTest - handler 4 处理写任务
23:45:21.793 [nioEventLoopGroup-2-2] DEBUG com.lboyang.chapter02.PipelineTest - handler 3 处理写任务
通过channel.pipeline().addLast(name, handler)添加handler时，建议给handler取名字。这样可以调用pipeline的addAfter、addBefore等方法更灵活地向pipeline中添加handler
handler需要放入通道的pipeline中，才能根据放入顺序来使用handler
- pipeline是结构是一个带有head与tail指针的双向链表，其中的节点为handler
- 要通过ctx.fireChannelRead(msg)等方法，将当前handler的处理结果传递给下一个handler
- 当有入站（Inbound）操作时，会从head开始向后调用handler，直到handler不是处理Inbound操作为止
- 当有出站（Outbound）操作时，会从tail开始向前调用handler，直到handler不是处理Outbound操作为止
ch.writeAndFlush()
当handler中调用该方法进行写操作时，会触发Outbound操作，此时是从tail向前寻找OutboundHandler
ctx.writeAndFlush()
当handler中调用该方法进行写操作时，会触发Outbound操作，此时是从当前handler向前寻找OutboundHandler
六、ByteBuf
调试工具类
帮助查看ByteBuf中的内容
public class ByteUtil {
public static void log(ByteBuf buffer) {
int length = buffer.readableBytes();
int rows = length / 16 + (length % 15 == 0 ? 0 : 1) + 4;
StringBuilder buf = new StringBuilder(rows * 80 * 2)
.append("read index:").append(buffer.readerIndex())
.append(" write index:").append(buffer.writerIndex())
.append(" capacity:").append(buffer.capacity())
.append(NEWLINE);
appendPrettyHexDump(buf, buffer);
System.out.println(buf.toString());
}
}
1. 创建
public class ByteBufTest {
public static void main(String[] args) {
// 通过该方法创建ByteBuf
ByteBuf buf = ByteBufAllocator.DEFAULT.buffer(10);
ByteUtil.log(buf);
// 想buf中写入数据，ByteBuf会自动扩容
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 20; i++) {
sb.append("a");
}
buf.writeBytes(sb.toString().getBytes());
ByteUtil.log(buf);
}
}
-
ByteBuf通过ByteBufAllocator选择allocator并调用对应的buffer()方法来创建的，默认使用直接内存作为ByteBuf，容量为256个字节，可以指定初始容量的大小
-
当ByteBuf的容量无法容纳所有数据时，ByteBuf会进行自动扩容操作
-
如果在handler中创建ByteBuf，建议**使用ChannelHandlerContext ctx.alloc().buffer()**来创建
2. 直接内存与堆内存
- 通过该方法创建的ByteBuf，使用的是基于直接内存的ByteBuf
ByteBuf buf = ByteBufAllocator.DEFAULT.buffer(10);
- 可以使用下面的代码来创建池化基于堆的 ByteBuf
ByteBuf buf = ByteBufAllocator.DEFAULT.heapBuffer(10);
- 也可以使用下面的代码来创建池化基于直接内存的 ByteBuf
ByteBuf buf = ByteBufAllocator.DEFAULT.directBuffer(10);
- 直接内存创建和销毁的代价昂贵，但读写性能高（少一次内存复制），适合配合池化功能一起用
- 直接内存对 GC 压力小，因为这部分内存不受 JVM 垃圾回收的管理，但也要注意及时主动释放
3. 池化与非池化
池化的最大意义在于可以重用 ByteBuf，类比数据库连接池以及线程池。优点有
- 没有池化，则每次都得创建新的 ByteBuf 实例，这个操作对直接内存代价昂贵，就算是堆内存，也会增加 GC 压力
- 有了池化，则可以重用池中 ByteBuf 实例，并且采用了与 jemalloc 类似的内存分配算法提升分配效率
- 高并发时，池化功能更节约内存，减少内存溢出的可能
池化功能是否开启，可以通过下面的系统环境变量来设置
4. 组成部分
ByteBuf主要有以下几个组成部分：
- 最大容量与当前容量
- 在构造ByteBuf时，可传入两个参数，分别代表初始容量和最大容量，若未传入第二个参数（最大容量），最大容量默认为Integer.MAX_VALUE
- 当ByteBuf容量无法容纳所有数据时，会进行扩容操作，若超出最大容量，会抛出java.lang.IndexOutOfBoundsException异常
- 读写操作不同于ByteBuffer只用position进行控制，ByteBuf分别由读指针和写指针两个指针控制。进行读写操作时，无需进行模式的切换
- 读指针前的部分被称为废弃部分，是已经读过的内容
- 读指针与写指针之间的空间称为可读部分
- 写指针与当前容量之间的空间称为可写部分
扩容规则
- 如果写入后数据大小未超过 512 字节，则选择下一个 16 的整数倍进行扩容
- 例如写入后大小为 12 字节，则扩容后 capacity 是 16 字节
- 如果写入后数据大小超过 512 字节，则选择下一个 2n
- 例如写入后大小为 513 字节，则扩容后 capacity 是 210=1024 字节（29=512 已经不够了）
- 扩容不能超过 maxCapacity，否则会抛出java.lang.IndexOutOfBoundsException异常
读取
- 读取主要是通过一系列read方法进行读取，读取时会根据读取数据的字节数移动读指针
- 如果需要重复读取，需要调用buffer.markReaderIndex()对读指针进行标记，并通过buffer.resetReaderIndex()将读指针恢复到mark标记的位置
5. 释放
由于 Netty 中有堆外内存（直接内存）的 ByteBuf 实现，堆外内存最好是手动来释放，而不是等 GC 垃圾回收。
- UnpooledHeapByteBuf 使用的是 JVM 内存，只需等 GC 回收内存即可
- UnpooledDirectByteBuf 使用的就是直接内存了，需要特殊的方法来回收内存
- PooledByteBuf 和它的子类使用了池化机制，需要更复杂的规则来回收内存
Netty 这里采用了引用计数法来控制回收内存，每个 ByteBuf 都实现了 ReferenceCounted 接口
- 每个 ByteBuf 对象的初始计数为 1
- 调用 release 方法计数减 1，如果计数为 0，ByteBuf 内存被回收
- 调用 retain 方法计数加 1，表示调用者没用完之前，其它 handler 即使调用了 release 也不会造成回收
- 当计数为 0 时，底层内存会被回收，这时即使 ByteBuf 对象还在，其各个方法均无法正常使用
释放规则
因为 pipeline 的存在，一般需要将 ByteBuf 传递给下一个 ChannelHandler，如果在每个 ChannelHandler 中都去调用 release ，就失去了传递性（如果在这个 ChannelHandler 内这个 ByteBuf 已完成了它的使命，那么便无须再传递）
基本规则是，谁是最后使用者，谁负责 release
- 起点，对于 NIO 实现来讲，在 io.netty.channel.nio.AbstractNioByteChannel.NioByteUnsafe.read 方法中首次创建 ByteBuf 放入 pipeline（line 163 pipeline.fireChannelRead(byteBuf)）
- 入站 ByteBuf 处理原则
- 对原始 ByteBuf 不做处理，调用 ctx.fireChannelRead(msg) 向后传递，这时无须 release
- 将原始 ByteBuf 转换为其它类型的 Java 对象，这时 ByteBuf 就没用了，必须 release
- 如果不调用 ctx.fireChannelRead(msg) 向后传递，那么也必须 release
- 注意各种异常，如果 ByteBuf 没有成功传递到下一个 ChannelHandler，必须 release
- 假设消息一直向后传，那么 TailContext 会负责释放未处理消息（原始的 ByteBuf）
- 出站 ByteBuf 处理原则
- 出站消息最终都会转为 ByteBuf 输出，一直向前传，由 HeadContext flush 后 release
- 异常处理原则
- 有时候不清楚 ByteBuf 被引用了多少次，但又必须彻底释放，可以循环调用 release 直到返回 true
当ByteBuf被传到了pipeline的head与tail时，ByteBuf会被其中的方法彻底释放，但前提是ByteBuf被传递到了head与tail中
切片
ByteBuf切片是【零拷贝】的体现之一，对原始 ByteBuf 进行切片成多个 ByteBuf，切片后的 ByteBuf 并没有发生内存复制，还是使用原始 ByteBuf 的内存，切片后的 ByteBuf 维护独立的 read，write 指针
得到分片后的buffer后，要调用其retain方法，使其内部的引用计数加一。避免原ByteBuf释放，导致切片buffer无法使用
修改原ByteBuf中的值，也会影响切片后得到的ByteBuf
优势
- 池化思想 - 可以重用池中 ByteBuf 实例，更节约内存，减少内存溢出的可能
- 读写指针分离，不需要像 ByteBuffer 一样切换读写模式
- 可以自动扩容
- 支持链式调用，使用更流畅
- 很多地方体现零拷贝，例如
- slice、duplicate、CompositeByteBuf
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
