网络通信2-io|nio|netty

1、IO编程

传统的 IO 编程，相信大家都不陌生，它能够实现客户端和服务端的通信，但是却是阻塞 IO。
我们来通过 IO 实现一个简单的场景：客户端每隔两秒发送一个带有时间戳的 “hello world” 给服务端，服务端收到之后打印出来。
下面是传统的 IO 编程中服务端的实现：IOServer.java

/**
 */
public class IOServer {
    public static void main(String[] args) throws Exception {

        ServerSocket serverSocket = new ServerSocket(8000);

        // (1) 接收新连接线程
        new Thread(() -> {
            while (true) {
                try {
                    // (1) 阻塞方法获取新的连接
                    Socket socket = serverSocket.accept();

                    // (2) 每一个新的连接都创建一个线程，负责读取数据
                    new Thread(() -> {
                        try {
                            int len;
                            byte[] data = new byte[1024];
                            InputStream inputStream = socket.getInputStream();
                            // (3) 按字节流方式读取数据
                            while ((len = inputStream.read(data)) != -1) {
                                System.out.println(new String(data, 0, len));
                            }
                        } catch (IOException e) {
                        }
                    }).start();

                } catch (IOException e) {
                }

            }
        }).start();
    }
}

Server 端首先创建一个serverSocket来监听8000端口，然后创建一个线程，线程里面不断调用阻塞方法serverSocket.accept()获取新的连接，见(1)。当获取到新的连接之后，给每条连接创建一个新的线程，这个线程负责从该连接中读取数据，见(2)，然后读取数据是以字节流的方式，见(3)。
下面是传统的 IO 编程中的客户端实现：IOClient.java

/**
 */
public class IOClient {

    public static void main(String[] args) {
        new Thread(() -> {
            try {
                Socket socket = new Socket("127.0.0.1", 8000);
                while (true) {
                    try {
                        socket.getOutputStream().write((new Date() + ": hello world").getBytes());
                        Thread.sleep(2000);
                    } catch (Exception e) {
                    }
                }
            } catch (IOException e) {
            }
        }).start();
    }
}

客户端相对简单，连接上服务端的8000端口之后，每隔2秒，我们向服务端写一个带有时间戳的"hello world"。
IO 编程模型在客户端较少的情况下运行良好，但是对于客户端比较多的业务来说，单机服务端可能需要支撑成千上万的连接，IO 模型可能就不太合适了，我们来分析以下原因。
上面的 demo，从服务端代码中我们可以看到，在传统的 IO 模型中，每个连接创建成功之后都需要一个线程来维护，每个线程包含一个 while 死循环，那么 1w 个连接对应 1w 个线程，继而 1w 个 while 死循环，这就带来了如下几个问题：

1、线程资源受限：线程是操作系统中非常宝贵的资源，同一时刻有大量的线程处于阻塞状态是非常严重的资源浪费，操作系统耗不起；
2、线程切换效率低下：单机 CPU 核数固定，线程爆炸之后操作系统频繁进行线程切换，应用性能急剧下降；
3、数据读写是以字节流为单位，效率不佳。

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

2、NIO 编程

NIO 是 对阻塞 IO 的改进，它是异步非阻塞的 IO。下面简单描述一下 NIO 是如何解决以上三个问题，从而做到异步非阻塞的。

1、bio问题及改进

1)线程资源受限

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

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

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

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

1、每个小朋友配一个老师。每个老师隔段时间询问小朋友是否要上厕所，如果要上，就领他去厕所，100 个小朋友就需要 100 个老师来询问，并且每个小朋友上厕所的时候都需要一个老师领着他去上，这就是IO模型，一个连接对应一个线程。

2、所有的小朋友都配同一个老师。这个老师隔段时间询问所有的小朋友是否有人要上厕所，然后每一时刻把所有要上厕所的小朋友批量领到厕所，这就是 NIO 模型，所有小朋友都注册到同一个老师，对应的就是所有的连接都注册到一个线程，然后批量轮询。

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

2)线程切换效率低下

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

3)IO读写面向流

IO 读写是面向流的，一次性只能从流中读取一个或者多个字节，并且读完之后流无法再读取，你需要自己缓存数据。 而 NIO 的读写是面向 Buffer 的，你可以随意读取里面任何一个字节数据，不需要你自己缓存数据，这一切只需要移动读写指针即可。
NIO 中有两个重要的概念：Buffer 和 Channel

Buffer:

• 是一块连续的内存块。
• 是 NIO 数据读或写的中转地。

Channel:

• 数据的源头或者数据的目的地
• 用于向 buffer 提供数据或者读取 buffer 数据 ,buffer 对象的唯一接口。
• 异步 I/O 支持

Buffer 作为 IO 流中数据的缓冲区，而 Channe l 则作为 socket 的 IO 流与 Buffer 的传输通道。客户端 socket 与服务端 socket 之间的 IO 传输不直接把数据交给 CPU 使用，而是先经过 Channel 通道把数据保存到 Buffer，然后 CPU 直接从 Buffer 区读写数据，一次可以读写更多的内容。

使用 Buffer 提高 IO 效率的原因（这里与IO流里面的 BufferedXXStream、BufferedReader、BufferedWriter 提高性能的原理一样）：IO 的耗时主要花在数据传输的路上，普通的 IO 是一个字节一个字节地传输，而采用了 Buffer 的话，通过 Buffer 封装的方法（比如一次读一行，则以行为单位传输而不是一个字节一次进行传输）就可以实现“一大块字节”的传输。比如：IO 就是送快递，普通 IO 是一个快递跑一趟，采用了 Buffer 的 IO 就是一车跑一趟。很明显，buffer 效率更高，花在传输路上的时间大大缩短。

2、nio实现

1）代码

/**
 */
public class NIOServer {
    public static void main(String[] args) throws IOException {
        Selector serverSelector = Selector.open();
        Selector clientSelector = Selector.open();

        new Thread(() -> {
            try {
                // 对应IO编程中服务端启动
                ServerSocketChannel listenerChannel = ServerSocketChannel.open();
                listenerChannel.socket().bind(new InetSocketAddress(8000));
                listenerChannel.configureBlocking(false);
                listenerChannel.register(serverSelector, SelectionKey.OP_ACCEPT);

                while (true) {
                    // 监测是否有新的连接，这里的1指的是阻塞的时间为 1ms
                    if (serverSelector.select(1) > 0) {
                        Set<SelectionKey> set = serverSelector.selectedKeys();
                        Iterator<SelectionKey> keyIterator = set.iterator();

                        while (keyIterator.hasNext()) {
                            SelectionKey key = keyIterator.next();

                            if (key.isAcceptable()) {
                                try {
                                    // (1) 每来一个新连接，不需要创建一个线程，而是直接注册到clientSelector
                                    SocketChannel clientChannel = ((ServerSocketChannel) key.channel()).accept();
                                    clientChannel.configureBlocking(false);
                                    clientChannel.register(clientSelector, SelectionKey.OP_READ);
                                } finally {
                                    keyIterator.remove();
                                }
                            }

                        }
                    }
                }
            } catch (IOException ignored) {
            }

        }).start();


        new Thread(() -> {
            try {
                while (true) {
                    // (2) 批量轮询是否有哪些连接有数据可读，这里的1指的是阻塞的时间为 1ms
                    if (clientSelector.select(1) > 0) {
                        Set<SelectionKey> set = clientSelector.selectedKeys();
                        Iterator<SelectionKey> keyIterator = set.iterator();

                        while (keyIterator.hasNext()) {
                            SelectionKey key = keyIterator.next();

                            if (key.isReadable()) {
                                try {
                                    SocketChannel clientChannel = (SocketChannel) key.channel();
                                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                                    // (3) 面向 Buffer
                                    clientChannel.read(byteBuffer);
                                    byteBuffer.flip();
                                    System.out.println(Charset.defaultCharset().newDecoder().decode(byteBuffer)
                                            .toString());
                                } finally {
                                    keyIterator.remove();
                                    key.interestOps(SelectionKey.OP_READ);
                                }
                            }

                        }
                    }
                }
            } catch (IOException ignored) {
            }
        }).start();
    }
}

2）核心思路：

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

3）不建议直接用

1、对于 NIO 编程来说，一个比较合适的线程模型能充分发挥它的优势，而 JDK 没有给你实现，你需要自己实现，就连简单的自定义协议拆包都要你自己实现；
2、项目庞大之后，自行实现的 NIO 很容易出现各类 bug，维护成本较高。
JDK 的 NIO 犹如带刺的玫瑰，正因为如此，Netty 横空出世！

3、 传统IO与NIO比较

3.1传统IO特点

阻塞点
server.accept();
inputStream.read(bytes);
单线程情况下只能有一个客户端
用线程池可以有多个客户端连接，但是非常消耗性能
=分割线====

3.2NIO的特点

ServerSocketChannel ServerSocket 餐厅
SocketChannel Socket 大门
Selector 服务生 一对多非阻塞
SelectionKey 客人
服务生selector监听select（）阻塞直到有新事件
是否大门新来客人，或者已有客人发来请求（点菜）
传统io相当于一个服务生对一个客人。要服务多个客人，就要线程池创建多个线程

3.3NIO的一些疑问

1）客户端关闭的时候会抛出异常，死循环
解决方案
int read = channel.read(buffer);
if(read > 0){
byte[] data = buffer.array();
String msg = new String(data).trim();
System.out.println(“服务端收到信息：” + msg);

		//回写数据
		ByteBuffer outBuffer = ByteBuffer.wrap("好的".getBytes());
		channel.write(outBuffer);// 将消息回送给客户端
	}else{
		System.out.println("客户端关闭");
		key.cancel();
	}

2）selector.select();阻塞，那为什么说nio是非阻塞的IO？
selector.select()
selector.select(1000);不阻塞
selector.wakeup();也可以唤醒selector
selector.selectNow();也可以立马返还，视频里忘了讲了，哈，这里补上

3）SelectionKey.OP_WRITE是代表什么意思
OP_WRITE表示底层缓冲区是否有空间，是则响应返还true；
一般不会注册这个事件，那么这个值默认为false

3、Netty 编程

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

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

接下来我们用 Netty 的版本来重新实现一下本文开篇的功能吧。

首先，引入 Maven 依赖

    <dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty-all</artifactId>
        <version>4.1.6.Final</version>
    </dependency>

然后，下面是服务端实现部分：NettyServer.java

/**
 */
public class NettyServer {
    public static void main(String[] args) {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();

        ServerBootstrap serverBootstrap = new ServerBootstrap();
        serverBootstrap
                .group(bossGroup, workerGroup )
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<NioSocketChannel>() {
                    protected void initChannel(NioSocketChannel ch) {
                        ch.pipeline().addLast(new StringDecoder());
                        ch.pipeline().addLast(new SimpleChannelInboundHandler<String>() {
                            @Override
                            protected void channelRead0(ChannelHandlerContext ctx, String msg) {
                                System.out.println(msg);
                            }
                        });
                    }
                })
                .bind(8000);
    }
}

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

• 首先看到，我们创建了NioEventLoopGroup，这两个对象可以看做是传统 IO 编程模型的两大线程组， bossGroup表示监听端口，acccpt 新连接的线程组，workerGroup表示处理每一个连接的数据读写的线程组。用生活中的例子来讲就是，一个工厂要运作，必然要一个老板负责从外面接活，然后有很多员工，负责具体干活，老板就是bossGroup，员工就是workerGroup，bossGroup接收完连接，扔给workerGroup去处理。
• 接下来我们创建一个引导类ServerBootstrap，这个类将引导我们进行服务端的启动工作，直接new出来开搞。
• 我们通过.group(bossGroup, workerGroup)给引导类配置两大线程组，这个引导类的线程模型也就定型了。
• 然后，我们指定我们服务端的 IO 模型为 NIO，我们通过.channel(NioServerSocketChannel.class)来指定 IO 模型，当然，这里也有其他的选择，如果你想指定 IO 模型为 BIO，那么这里配置上OioServerSocketChannel.class类型即可，当然通常我们也不会这么做，因为Netty的优势就在于 NIO。
• 接着，我们调用childHandler()方法，给这个引导类创建一个ChannelInitializer，这里主要就是定义后续每条连接的数据读写，业务处理逻辑。ChannelInitializer这个类中，我们注意到有一个泛型参数NioSocketChannel，这个类呢，就是 Netty 对 NIO 类型的连接的抽象，而我们前面NioServerSocketChannel也是对 NIO 类型的连接的抽象，NioServerSocketChannel和NioSocketChannel的概念可以和 BIO 编程模型中的ServerSocket以及Socket两个概念对应上。

我们的最小化参数配置到这里就完成了，我们总结一下就是，要启动一个Netty服务端，必须要指定三类属性，分别是线程模型、IO 模型、连接读写处理逻辑，有了这三者，之后在调用bind(8000)，我们就可以在本地绑定一个 8000 端口启动起来，以上这段代码读者可以直接拷贝到你的 IDE 中运行。

然后下面是客户端 NIO 的实现部分：NettyClient.java

/**
 */
public class NettyClient {
    public static void main(String[] args) throws InterruptedException {
        Bootstrap bootstrap = new Bootstrap();
        NioEventLoopGroup group = new NioEventLoopGroup();

        bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<Channel>() {
                    @Override
                    protected void initChannel(Channel ch) {
                        ch.pipeline().addLast(new StringEncoder());
                    }
                });

        Channel channel = bootstrap.connect("127.0.0.1", 8000).channel();

        while (true) {
            channel.writeAndFlush(new Date() + ": hello world!");
            Thread.sleep(2000);
        }
    }
}

从上面代码可以看到，客户端启动的引导类是 Bootstrap，负责启动客户端以及连接服务端，而上一小节我们在描述服务端的启动的时候，这个辅导类是 ServerBootstrap，引导类创建完成之后，下面我们描述一下客户端启动的流程。

• 首先，与服务端的启动一样，我们需要给它指定线程模型，驱动着连接的数据读写。
• 然后，我们指定 IO 模型为 NioSocketChannel，表示 IO 模型为 NIO，当然，你可以可以设置 IO 模型为 OioSocketChannel，但是通常不会这么做，因为 Netty 的优势在于 NIO。
• 接着，给引导类指定一个handler，这里主要就是定义连接的业务处理逻辑。
• 配置完线程模型、IO 模型、业务处理逻辑之后，调用 connect方法进行连接，可以看到connect方法有两个参数，第一个参数可以填写 IP 或者域名，第二个参数填写的是端口号。

到了这里，一个客户端的启动的 Demo 就完成了，其实只要和 客户端 Socket 编程模型对应起来，这里的三个概念就会显得非常简单。