Netty入门（二）——传统IO与NIO比较（二）

淩亂°似流年 2022-05-22 11:45 200阅读 0赞

## 此博客是引用占小狼公众号的文章，讲解非常好，对初学者能够有非常好的认识。大家可关注该公众号。 ##

## IO编程 ##

我们简化下场景：客户端每隔两秒发送一个带有时间戳的"hello world"给服务端，服务端收到之后打印。

为了方便演示，下面例子中，服务端和客户端各一个类，把这两个类拷贝到你的IDE中，先后运行 `IOServer.java`和 `IOClient.java`可看到效果。

下面是传统的IO编程中服务端实现

> IOServer.java

1.  `/**`
2.  `* @author 闪电侠`
3.  `*/`
4.  `public class IOServer {`
5.  `   public static void main(String[] args) throws Exception {`
6.  ``
7.  `       ServerSocket serverSocket = new ServerSocket(8000);`
8.  ``
9.  `       // (1) 接收新连接线程`
10. `       new Thread(() -> {`
11. `           while (true) {`
12. `               try {`
13. `                   // (1) 阻塞方法获取新的连接`
14. `                   Socket socket = serverSocket.accept();`
15. ``
16. `                   // (2) 每一个新的连接都创建一个线程，负责读取数据`
17. `                   new Thread(() -> {`
18. `                       try {`
19. `                           byte[] data = new byte[1024];`
20. `                           InputStream inputStream = socket.getInputStream();`
21. `                           while (true) {`
22. `                               int len;`
23. `                               // (3) 按字节流方式读取数据`
24. `                               while ((len = inputStream.read(data)) != -1) {`
25. `                                   System.out.println(new String(data, 0, len));`
26. `                               }`
27. `                           }`
28. `                       } catch (IOException e) {`
29. `                       }`
30. `                   }).start();`
31. ``
32. `               } catch (IOException e) {`
33. `               }`
34. ``
35. `           }`
36. `       }).start();`
37. `   }`
38. `}`

server端首先创建了一个 `serverSocket`来监听8000端口，然后创建一个线程，线程里面不断调用阻塞方法 `serversocket.accept();`获取新的连接，见(1)，当获取到新的连接之后，给每条连接创建一个新的线程，这个线程负责从该连接中读取数据，见(2)，然后读取数据是以字节流的方式，见(3)。

下面是传统的IO编程中客户端实现

> IOClient.java

1.  `/**`
2.  `* @author 闪电侠`
3.  `*/`
4.  `public class IOClient {`
5.  ``
6.  `   public static void main(String[] args) {`
7.  `       new Thread(() -> {`
8.  `           try {`
9.  `               Socket socket = new Socket("127.0.0.1", 8000);`
10. `               while (true) {`
11. `                   try {`
12. `                       socket.getOutputStream().write((new Date() + ": hello world").getBytes());`
13. `                       socket.getOutputStream().flush();`
14. `                       Thread.sleep(2000);`
15. `                   } catch (Exception e) {`
16. `                   }`
17. `               }`
18. `           } catch (IOException e) {`
19. `           }`
20. `       }).start();`
21. `   }`
22. `}`

客户端的代码相对简单，连接上服务端8000端口之后，每隔2秒，我们向服务端写一个带有时间戳的 "hello world"。

IO编程模型在客户端较少的情况下运行良好，但是对于客户端比较多的业务来说，单机服务端可能需要支撑成千上万的连接，IO模型可能就不太合适了，我们来分析一下原因。

上面的demo，从服务端代码中我们可以看到，在传统的IO模型中，每个连接创建成功之后都需要一个线程来维护，每个线程包含一个while死循环，那么1w个连接对应1w个线程，继而1w个while死循环，这就带来如下几个问题：

1.  线程资源受限：线程是操作系统中非常宝贵的资源，同一时刻有大量的线程处于阻塞状态是非常严重的资源浪费，操作系统耗不起
2.  线程切换效率低下：单机cpu核数固定，线程爆炸之后操作系统频繁进行线程切换，应用性能急剧下降。
3.  除了以上两个问题，IO编程中，我们看到数据读写是以字节流为单位，效率不高。

为了解决这三个问题，JDK在1.4之后提出了NIO。

## NIO编程 ##

关于NIO相关的文章网上也有很多，这里不打算详细深入分析，下面简单描述一下NIO是如何解决以上三个问题的。

### 线程资源受限 ###

NIO编程模型中，新来一个连接不再创建一个新的线程，而是可以把这条连接直接绑定到某个固定的线程，然后这条连接所有的读写都由这个线程来负责，那么他是怎么做到的？我们用一幅图来对比一下IO与NIO

![70][]

如上图所示，IO模型中，一个连接来了，会创建一个线程，对应一个while死循环，死循环的目的就是不断监测这条连接上是否有数据可以读，大多数情况下，1w个连接里面同一时刻只有少量的连接有数据可读，因此，很多个while死循环都白白浪费掉了，因为读不出啥数据。

而在NIO模型中，他把这么多while死循环变成一个死循环，这个死循环由一个线程控制，那么他又是如何做到一个线程，一个while死循环就能监测1w个连接是否有数据可读的呢？ 这就是NIO模型中selector的作用，一条连接来了之后，现在不创建一个while死循环去监听是否有数据可读了，而是直接把这条连接注册到selector上，然后，通过检查这个selector，就可以批量监测出有数据可读的连接，进而读取数据，下面我再举个非常简单的生活中的例子说明IO与NIO的区别。

在一家幼儿园里，小朋友有上厕所的需求，小朋友都太小以至于你要问他要不要上厕所，他才会告诉你。幼儿园一共有100个小朋友，有两种方案可以解决小朋友上厕所的问题：

1.  每个小朋友配一个老师。每个老师隔段时间询问小朋友是否要上厕所，如果要上，就领他去厕所，100个小朋友就需要100个老师来询问，并且每个小朋友上厕所的时候都需要一个老师领着他去上，这就是IO模型，一个连接对应一个线程。
2.  所有的小朋友都配同一个老师。这个老师隔段时间询问所有的小朋友是否有人要上厕所，然后每一时刻把所有要上厕所的小朋友批量领到厕所，这就是NIO模型，所有小朋友都注册到同一个老师，对应的就是所有的连接都注册到一个线程，然后批量轮询。

这就是NIO模型解决线程资源受限的方案，实际开发过程中，我们会开多个线程，每个线程都管理着一批连接，相对于IO模型中一个线程管理一条连接，消耗的线程资源大幅减少

### 线程切换效率低下 ###

由于NIO模型中线程数量大大降低，线程切换效率因此也大幅度提高

### IO读写以字节为单位 ###

NIO解决这个问题的方式是数据读写不再以字节为单位，而是以字节块为单位。IO模型中，每次都是从操作系统底层一个字节一个字节地读取数据，而NIO维护一个缓冲区，每次可以从这个缓冲区里面读取一块的数据， 这就好比一盘美味的豆子放在你面前，你用筷子一个个夹（每次一个），肯定不如要勺子挖着吃（每次一批）效率来得高。

简单讲完了JDK NIO的解决方案之后，我们接下来使用NIO的方案替换掉IO的方案，我们先来看看，如果用JDK原生的NIO来实现服务端，该怎么做

> 前方高能预警：以下代码可能会让你感觉极度不适，如有不适，请跳过
> 
> NIOServer.java

1.  `/**`
2.  `* @author 闪电侠`
3.  `*/`
4.  `public class NIOServer {`
5.  `   public static void main(String[] args) throws IOException {`
6.  `       Selector serverSelector = Selector.open();`
7.  `       Selector clientSelector = Selector.open();`
8.  ``
9.  `       new Thread(() -> {`
10. `           try {`
11. `               // 对应IO编程中服务端启动`
12. `               ServerSocketChannel listenerChannel = ServerSocketChannel.open();`
13. `               listenerChannel.socket().bind(new InetSocketAddress(8000));`
14. `               listenerChannel.configureBlocking(false);`
15. `               listenerChannel.register(serverSelector, SelectionKey.OP_ACCEPT);`
16. ``
17. `               while (true) {`
18. `                   // 监测是否有新的连接，这里的1指的是阻塞的时间为1ms`
19. `                   if (serverSelector.select(1) > 0) {`
20. `                       Set<SelectionKey> set = serverSelector.selectedKeys();`
21. `                       Iterator<SelectionKey> keyIterator = set.iterator();`
22. ``
23. `                       while (keyIterator.hasNext()) {`
24. `                           SelectionKey key = keyIterator.next();`
25. ``
26. `                           if (key.isAcceptable()) {`
27. `                               try {`
28. `                                   // (1) 每来一个新连接，不需要创建一个线程，而是直接注册到clientSelector`
29. `                                   SocketChannel clientChannel = ((ServerSocketChannel) key.channel()).accept();`
30. `                                   clientChannel.configureBlocking(false);`
31. `                                   clientChannel.register(clientSelector, SelectionKey.OP_READ);`
32. `                               } finally {`
33. `                                   keyIterator.remove();`
34. `                               }`
35. `                           }`
36. ``
37. `                       }`
38. `                   }`
39. `               }`
40. `           } catch (IOException ignored) {`
41. `           }`
42. ``
43. `       }).start();`
44. ``
45. ``
46. `       new Thread(() -> {`
47. `           try {`
48. `               while (true) {`
49. `                   // (2) 批量轮询是否有哪些连接有数据可读，这里的1指的是阻塞的时间为1ms`
50. `                   if (clientSelector.select(1) > 0) {`
51. `                       Set<SelectionKey> set = clientSelector.selectedKeys();`
52. `                       Iterator<SelectionKey> keyIterator = set.iterator();`
53. ``
54. `                       while (keyIterator.hasNext()) {`
55. `                           SelectionKey key = keyIterator.next();`
56. ``
57. `                           if (key.isReadable()) {`
58. `                               try {`
59. `                                   SocketChannel clientChannel = (SocketChannel) key.channel();`
60. `                                   ByteBuffer byteBuffer = ByteBuffer.allocate(1024);`
61. `                                   // (3) 读取数据以块为单位批量读取`
62. `                                   clientChannel.read(byteBuffer);`
63. `                                   byteBuffer.flip();`
64. `                                   System.out.println(Charset.defaultCharset().newDecoder().decode(byteBuffer)`
65. `                                           .toString());`
66. `                               } finally {`
67. `                                   keyIterator.remove();`
68. `                                   key.interestOps(SelectionKey.OP_READ);`
69. `                               }`
70. `                           }`
71. ``
72. `                       }`
73. `                   }`
74. `               }`
75. `           } catch (IOException ignored) {`
76. `           }`
77. `       }).start();`
78. ``
79. ``
80. `   }`
81. `}`

相信大部分没有接触过NIO的同学应该会直接跳过代码来到这一行：原来使用JDK原生NIO的API实现一个简单的服务端通信程序是如此复杂!

复杂得我都没耐心解释这一坨代码的执行逻辑(开个玩笑)，我们还是先对照NIO来解释一下几个核心思路

1.  NIO模型中通常会有两个线程，每个线程绑定一个轮询器selector，在我们这个例子中 `serverSelector`负责轮询是否有新的连接， `clientSelector`负责轮询连接是否有数据可读
2.  服务端监测到新的连接之后，不再创建一个新的线程，而是直接将新连接绑定到 `clientSelector`上，这样就不用IO模型中1w个while循环在死等，参见(1)
3.  `clientSelector`被一个while死循环包裹着，如果在某一时刻有多条连接有数据可读，那么通过 `clientSelector.select(1)`方法可以轮询出来，进而批量处理，参见(2)
4.  数据的读写以内存块为单位，参见(3)

其他的细节部分，我不愿意多讲，因为实在是太复杂，你也不用对代码的细节深究到底。总之，强烈不建议直接基于JDK原生NIO来进行网络开发，下面是我总结的原因

1、JDK的NIO编程需要了解很多的概念，编程复杂，对NIO入门非常不友好，编程模型不友好，ByteBuffer的api简直反人类 2、对NIO编程来说，一个比较合适的线程模型能充分发挥它的优势，而JDK没有给你实现，你需要自己实现，就连简单的自定义协议拆包都要你自己实现 3、JDK的NIO底层由epoll实现，该实现饱受诟病的空轮训bug会导致cpu飙升100% 4、项目庞大之后，自行实现的NIO很容易出现各类bug，维护成本较高，上面这一坨代码我都不能保证没有bug

正因为如此，我客户端代码都懒得写给你看了==!，你可以直接使用 `IOClient.java`与 `NIOServer.java`通信

JDK的NIO犹如带刺的玫瑰，虽然美好，让人向往，但是使用不当会让你抓耳挠腮，痛不欲生，正因为如此，Netty横空出世！

## Netty编程 ##

那么Netty到底是何方神圣？ 用一句简单的话来说就是：Netty封装了JDK的NIO，让你用得更爽，你不用再写一大堆复杂的代码了。 用官方正式的话来说就是：Netty是一个异步事件驱动的网络应用框架，用于快速开发可维护的高性能服务器和客户端。

下面是我总结的使用Netty不使用JDK原生NIO的原因

1.  使用JDK自带的NIO需要了解太多的概念，编程复杂，一不小心bug横飞
2.  Netty底层IO模型随意切换，而这一切只需要做微小的改动，改改参数，Netty可以直接从NIO模型变身为IO模型
3.  Netty自带的拆包解包，异常检测等机制让你从NIO的繁重细节中脱离出来，让你只需要关心业务逻辑
4.  Netty解决了JDK的很多包括空轮询在内的bug
5.  Netty底层对线程，selector做了很多细小的优化，精心设计的reactor线程模型做到非常高效的并发处理
6.  自带各种协议栈让你处理任何一种通用协议都几乎不用亲自动手
7.  Netty社区活跃，遇到问题随时邮件列表或者issue
8.  Netty已经历各大rpc框架，消息中间件，分布式通信中间件线上的广泛验证，健壮性无比强大

看不懂没有关系，这些我们在后续的课程中我们都可以学到，接下来我们用Netty的版本来重新实现一下本文开篇的功能吧

首先，引入Maven依赖

1.  `   <dependency>`
2.  `       <groupId>io.netty</groupId>`
3.  `       <artifactId>netty-all</artifactId>`
4.  `       <version>4.1.6.Final</version>`
5.  `   </dependency>`

然后，下面是服务端实现部分

> NettyServer.java

1.  `/**`
2.  `* @author 闪电侠`
3.  `*/`
4.  `public class NettyServer {`
5.  `   public static void main(String[] args) {`
6.  `       ServerBootstrap serverBootstrap = new ServerBootstrap();`
7.  ``
8.  `       NioEventLoopGroup boos = new NioEventLoopGroup();`
9.  `       NioEventLoopGroup worker = new NioEventLoopGroup();`
10. `       serverBootstrap`
11. `               .group(boos, worker)`
12. `               .channel(NioServerSocketChannel.class)`
13. `               .childHandler(new ChannelInitializer<NioSocketChannel>() {`
14. `                   protected void initChannel(NioSocketChannel ch) {`
15. `                       ch.Pipeline().addLast(new StringDecoder());`
16. `                       ch.Pipeline().addLast(new SimpleChannelInboundHandler<String>() {`
17. `                           @Override`
18. `                           protected void channelRead0(ChannelHandlerContext ctx, String msg) {`
19. `                               System.out.println(msg);`
20. `                           }`
21. `                       });`
22. `                   }`
23. `               })`
24. `               .bind(8000);`
25. `   }`
26. `}`

这么一小段代码就实现了我们前面NIO编程中的所有的功能，包括服务端启动，接受新连接，打印客户端传来的数据，怎么样，是不是比JDK原生的NIO编程优雅许多？

初学Netty的时候，由于大部分人对NIO编程缺乏经验，因此，将Netty里面的概念与IO模型结合起来可能更好理解

1. `boos`对应了 `IOServer.java`中的接收新连接线程，主要负责创建新连接 2. `worker`对应 `IOClient.java`中的负责读取数据的线程，主要用于读取数据以及业务逻辑处理

然后剩下的逻辑我在后面的系列文章中会详细分析，你可以先把这段代码拷贝到你的IDE里面，然后运行main函数

然后下面是客户端NIO的实现部分

> NettyClient.java

1.  `/**`
2.  `* @author 闪电侠`
3.  `*/`
4.  `public class NettyClient {`
5.  `   public static void main(String[] args) throws InterruptedException {`
6.  `       Bootstrap bootstrap = new Bootstrap();`
7.  `       NioEventLoopGroup group = new NioEventLoopGroup();`
8.  ``
9.  `       bootstrap.group(group)`
10. `               .channel(NioSocketChannel.class)`
11. `               .handler(new ChannelInitializer<Channel>() {`
12. `                   @Override`
13. `                   protected void initChannel(Channel ch) {`
14. `                       ch.Pipeline().addLast(new StringEncoder());`
15. `                   }`
16. `               });`
17. ``
18. `       Channel channel = bootstrap.connect("127.0.0.1", 8000).channel();`
19. ``
20. `       while (true) {`
21. `           channel.writeAndFlush(new Date() + ": hello world!");`
22. `           Thread.sleep(2000);`
23. `       }`
24. `   }`
25. `}`

在客户端程序中， `group`对应了我们 `IOClient.java`中main函数起的线程，剩下的逻辑我在后面的文章中会详细分析，现在你要做的事情就是把这段代码拷贝到你的IDE里面，然后运行main函数，最后回到 `NettyIOServer.java`的控制台，你会看到效果。

使用Netty之后是不是觉得整个世界都美好了，一方面Netty对NIO封装得如此完美，写出来的代码非常优雅，另外一方面，使用Netty之后，网络通信这块的性能问题几乎不用操心，尽情地让Netty榨干你的CPU吧。

[70]: /images/20220522/9fbf5d533d8f400097833d9e1ccf6089.png