Netty之Channel解读-阿里云开发者社区

Netty之Channel解读

2023-07-26 45

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： Netty之Channel解读

channel 的主要作用

close() 可以用来关闭 channel
closeFuture() 用来处理 channel 的关闭

sync 方法作用是同步等待 channel 关闭
而 addListener 方法是异步等待 channel 关闭

pipeline() 方法添加处理器
write() 方法将数据写入
writeAndFlush() 方法将数据写入并刷出

ChannelFuture

下面是一段客户端的代码

1. new Bootstrap()
2.     .group(new NioEventLoopGroup())
3.     .channel(NioSocketChannel.class)
4.     .handler(new ChannelInitializer<Channel>() {
5. @Override
6. protected void initChannel(Channel ch) {
7.             ch.pipeline().addLast(new StringEncoder());
8.         }
9.     })
10.     .connect("127.0.0.1", 8080)
11.     .sync()
12.     .channel()
13.     .writeAndFlush(new Date() + ": hello world!");

现在把它拆开来看

1. ChannelFuture channelFuture = new Bootstrap()
2.     .group(new NioEventLoopGroup())
3.     .channel(NioSocketChannel.class)
4.     .handler(new ChannelInitializer<Channel>() {
5. @Override
6. protected void initChannel(Channel ch) {
7.             ch.pipeline().addLast(new StringEncoder());
8.         }
9.     })
10.     .connect("127.0.0.1", 8080); // 1
11. 
12. channelFuture.sync().channel().writeAndFlush(new Date() + ": hello world!");

1 处返回的是 ChannelFuture 对象，它的作用是利用 channel() 方法来获取 Channel 对象

注意 connect 方法是异步的，意味着不等连接建立，方法执行就返回了。因此 channelFuture 对象中不能【立刻】获得到正确的 Channel 对象

实验如下：

1. ChannelFuture channelFuture = new Bootstrap()
2.     .group(new NioEventLoopGroup())
3.     .channel(NioSocketChannel.class)
4.     .handler(new ChannelInitializer<Channel>() {
5. @Override
6. protected void initChannel(Channel ch) {
7.             ch.pipeline().addLast(new StringEncoder());
8.         }
9.     })
10.     .connect("127.0.0.1", 8080);
11. 
12. System.out.println(channelFuture.channel()); // 1
13. channelFuture.sync(); // 2
14. System.out.println(channelFuture.channel()); // 3

执行到 1 时，连接未建立，打印 [id: 0x2e1884dd]

执行到 2 时，sync 方法是同步等待连接建立完成

执行到 3 时，连接肯定建立了，打印 [id: 0x2e1884dd, L:/127.0.0.1:57191 - R:/127.0.0.1:8080]

除了用 sync 方法可以让异步操作同步以外，还可以使用回调的方式：

1. ChannelFuture channelFuture = new Bootstrap()
2.     .group(new NioEventLoopGroup())
3.     .channel(NioSocketChannel.class)
4.     .handler(new ChannelInitializer<Channel>() {
5. @Override
6. protected void initChannel(Channel ch) {
7.             ch.pipeline().addLast(new StringEncoder());
8.         }
9.     })
10.     .connect("127.0.0.1", 8080);
11. System.out.println(channelFuture.channel()); // 1
12. channelFuture.addListener((ChannelFutureListener) future -> {
13.     System.out.println(future.channel()); // 2
14. });

执行到 1 时，连接未建立，打印 [id: 0x749124ba]

ChannelFutureListener 会在连接建立时被调用（其中 operationComplete 方法），因此执行到 2 时，连接肯定建立了，打印 [id: 0x749124ba, L:/127.0.0.1:57351 - R:/127.0.0.1:8080]

CloseFuture

关闭是由另外一个线程来进行处理的，跟上面的原理一样

这里可以看出CLOSE之前就执行了关闭操作

正确关闭的第一种方式：同步关闭处理

1. ChannelFuture closeFuture = channel.closeFuture();
2.         closeFuture.sync();
3.         log.debug("处理关闭以后的操作");

正确关闭的第二种方式：异步关闭处理

1.    closeFuture.addListener(new ChannelFutureListener() {
2. public void operationComplete(ChannelFuture future) throws Exception {
3.                 log.debug("处理关闭以后的操作");
4.                 group.shutdownGracefully();
5.             }
6.         });

上述的测试代码

1. @Slf4j
2. public class CloseFutureClient {
3. public static void main(String[] args) throws Exception{
4. NioEventLoopGroup group = new NioEventLoopGroup();
5. ChannelFuture channelFuture = new Bootstrap()
6.                 .group(group)
7.                 .channel(NioSocketChannel.class)
8.                 .handler(new ChannelInitializer<NioSocketChannel>() {
9. protected void initChannel(NioSocketChannel ch) throws Exception {
10.                         ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
11.                         ch.pipeline().addLast(new StringEncoder());
12.                     }
13.                 }).connect(new InetSocketAddress("localhost", 8080));
14. Channel channel = channelFuture.sync().channel();
15.         log.debug("{}",channel);
16. new Thread(()->{
17. Scanner scanner = new Scanner(System.in);
18. while (true){
19. String line = scanner.nextLine();
20. if("q".equals(line)){
21. 
22.                     channel.close();//close异步操作
23.                     log.debug("处理关闭之后的操作");//不能在这里善后 错误的
24. break;
25.                 }
26.             }
27.         },"input").start();
28. 
29. //获取CloseFuture对象
30. //1)同步关闭处理
31. //2)异步关闭处理
32. /*    ChannelFuture closeFuture = channel.closeFuture();
33.         closeFuture.sync();
34.         log.debug("处理关闭以后的操作"); */
35. 
36. ChannelFuture closeFuture = channel.closeFuture();
37.         closeFuture.addListener(new ChannelFutureListener() {
38. public void operationComplete(ChannelFuture future) throws Exception {
39.                 log.debug("处理关闭以后的操作");
40.                 group.shutdownGracefully();
41.             }
42.         });
43. 
44.     }
45. }

为什么要异步关闭

为什么不在一个线程中去执行建立连接、去执行关闭 channel，那样不是也可以吗？非要用这么复杂的异步方式：比如一个线程发起建立连接，另一个线程去真正建立连接。

还有人会笼统地回答，因为 netty 异步方式用了多线程、多线程就效率高。其实这些认识都比较片面，多线程和异步所提升的效率并不是所认为的

思考下面的场景，4 个医生给人看病，每个病人花费 20 分钟，而且医生看病的过程中是以病人为单位的，一个病人看完了，才能看下一个病人。假设病人源源不断地来，可以计算一下 4 个医生一天工作 8 小时，处理的病人总数是：4 * 8 * 3 = 96

经研究发现，看病可以细分为四个步骤，经拆分后每个步骤需要 5 分钟，如下

因此可以做如下优化，只有一开始，医生 2、3、4 分别要等待 5、10、15 分钟才能执行工作，但只要后续病人源源不断地来，他们就能够满负荷工作，并且处理病人的能力提高到了 4 * 8 * 12 效率几乎是原来的四倍，（一个小时内接待病人的效率大大提高，四个医生不是同时工作，但都要干满8小时才下班）

要点

单线程没法异步提高效率，必须配合多线程、多核 cpu 才能发挥异步的优势，单线程不能同时处理多个任务，因此无法实现异步处理提高效率。异步处理需要利用多线程或多进程机制来实现，以便同时处理多个任务。多线程或多进程能够允许程序同时执行多个操作，从而提高效率。
异步并没有缩短响应时间，反而有所增加，异步可以提高系统的吞吐量，即能够同时处理多个请
合理进行任务拆分，也是利用异步的关键

Netty之Channel解读

channel 的主要作用

ChannelFuture

CloseFuture

为什么要异步关闭

热门文章

最新文章

相关电子书