二、Netty入门到精通(RPC实现)——NIO的代码分析

女爷i 2023-08-17 16:50 97阅读 0赞

**目录**

1、NIO的网络传输方式

2、代码分析

3、Java IO和NIO之间的主要区别：

（1）、面向流与面向缓冲

（2）、阻塞与非阻塞IO

（3）、选择器（Selectors）

--------------------

## 1、NIO的网络传输方式 ##

NIO全称java non-blocking IO，是指jdk1.4 及以上版本里提供的新api（New IO） ，为所有的原始类型（boolean类型除外）提供缓存支持的数据容器，使用它可以提供非阻塞式的高伸缩性网络。

package traditional_socket;
    
    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.nio.ByteBuffer;
    import java.nio.channels.SelectionKey;
    import java.nio.channels.Selector;
    import java.nio.channels.ServerSocketChannel;
    import java.nio.channels.SocketChannel;
    import java.util.Iterator;
    
    /**
     * \* Created with IntelliJ IDEA.
     * \* User: sunxianpeng
     * \* Date: 2019/9/29
     * \* Time: 16:35
     * \* To change this template use File | Settings | File Templates.
     * \* Description:
     * \
     */
    public class NioServer {
        //通道通信
        private Selector selector;
        /**
         * 获得一个ServerSocket通道，并对该通道做一些初始化的工作
         * @param port 绑定的端口号
         * @throws IOException
         */
        public void initServer(int port) throws IOException {
            //获得一个ServerSocket通道
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            //设置通道为非阻塞
            serverSocketChannel.configureBlocking(false);
            //将通道对应的ServerSocket绑定到port端口
            serverSocketChannel.socket().bind(new InetSocketAddress(port));
            //获得一个通道管理器
            this.selector = Selector.open();
            //将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_ACCEPT事件，注册该事件后，
            //当该事件到达时，selector.select()会返回，如果该事件没到达selector.select()会一直阻塞
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        }
        /**
         * 采用轮询的方式监听selector是否有需要处理的事件，如果有，则进行处理
         * @throws IOException
         */
        public void listen() throws IOException {
            System.out.println("server start !!");
            //轮询访问selector
            while (true){
                //当注册的事件到达时，方法返回；否则，该方法会一直阻塞
                selector.select();
                //获得selector中选中的项的迭代器，选中的项为注册的事件
                Iterator<?> iterator = this.selector.selectedKeys().iterator();
                while (iterator.hasNext()){
                    SelectionKey key = (SelectionKey) iterator.next();
                    //删除已选的key，以防重复处理
                    iterator.remove();
                    handler(key);
                }
            }
        }
        /**
         *  处理请求
         * @param key
         */
        private void handler(SelectionKey key) throws IOException {
            if (key.isAcceptable()){//客户端请求连接事件
                handlerAccept(key);
            }else if (key.isReadable()){//获得了可读的事件
                handlerRead(key);
            }
        }
        /**
         * 处理连接请求
         * @param key
         * @throws IOException
         */
        private void handlerAccept(SelectionKey key) throws IOException {
            //获得ServerSocket
            ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
            //获得和客户端连接的通道
            SocketChannel channel = serverSocketChannel.accept();
            //设置成非阻塞
            channel.configureBlocking(false);
            System.out.println("new client connect");
            //服务端发给客户端的确认信息
            channel.write(ByteBuffer.wrap("server success to create connect".getBytes()));
            //在和客户端连接成功后，为了可以接收到客户端的信息，需要给通道设置读的权限
            channel.register(this.selector,SelectionKey.OP_READ);
        }
        /**
         * 处理可读的事件
         * @param key
         * @throws IOException
         */
        private void handlerRead(SelectionKey key) throws IOException {
            //获得ServerSocket
            SocketChannel channel = (SocketChannel) key.channel();
            //创建读取的缓冲区(每次读1000个字节)
            ByteBuffer buffer = ByteBuffer.allocate(1000);
            channel.read(buffer);
            byte[] data = buffer.array();
            String msg = new String(data).trim();
            System.out.println("server get info :"+ msg);
            ByteBuffer outBuffer = ByteBuffer.wrap(("服务端收到信息："+msg).getBytes());
            //将消息送回给客户端
            channel.write(outBuffer);
        }
        /**
         * 启动服务测试
         * @param args
         */
        public static void main(String[] args) throws IOException {
            NioServer nioServer = new NioServer();
            nioServer.initServer(10101);
            nioServer.listen();
        }
    
    }

## 2、代码分析 ##

**（1）概述**

*  ServerSocketChannel 类似传统 IO 的 ServerSocket
 *  SocketChannel 类似传统 IO 的 Socket
 *  Selector 以及 SelectionKey 相当于“选择器”和“选择事件类型”，是用来让一个单独的线程来“选择”通道的，这种选择机制，使得一个单独的线程很容易来管理多个通道。

**（2）initServer方法：初始化服务端信息**

*  打开一个ServerSocket通道，并设置为非阻塞
 *  将通道对应的ServerSocket绑定到port端口，这个端口就是服务端对外服务的端口
 *  然后获得一个通道管理器，并注册一个SelectionKey.OP\_ACCEPT事件，用于监听
 *  客户端发送过来的不同类型的请求。

**（3）listen方法：客户端监听，采取轮询的方式监听selector是否有需要处理的事件**

这里监听的就是两种主要请求类型：

*  连接请求：客户端对服务端的连接请求
 *  数据读取：客户端向服务端发送了信息，服务端接受并解析
 *  处理**连接请求**就进行通道获取和阻塞类型设置，并**设置通道读的权限**。
 *  处理**可读事件**就创建缓冲区读取**客户端信息**。

**（4）形象化描述**

*  整个过程就是，服务端(餐厅)初始化一个(服务员)selector(选择器，用于服务所有客户端)，
 *  selector 注册一个OP\_ACCEPT的KEY(老板口头交代服务员要接待大门进来的新客人)，意味着出现连接事件(客人来)的时候，selector需要去处理连接事件(接待客人)，并听取客户端的各种信息(建立连接还是点菜)，
 *  当 selector 接受连接请求类型(找位子准备点餐)时，为客户端进行注册(准备接受客户点菜)；
 *  当 selector 接受读取事类型(顾客点菜)时，听取客户端(顾客)的具体点餐信息。

**（5）在NIO中可以设置每个连接通道为“非阻塞”状态，这就意味着使用一个单线程，就可以开启多个客户端进行服务端的连接，不存在一个客户端一直占用单线程的情况。**

**（6）在windows 使用 telnet 开启多个客户端连接 server，是可以同时连接服务端的。**

## 3、Java IO和NIO之间的主要区别： ##

IO NIO  
面向流 面向缓冲  
阻塞IO 非阻塞IO  
无 选择器

### （1）、面向流与面向缓冲 ###

**a、io**

*  Java IO和NIO之间第一个最大的区别是，**IO是面向流的，NIO是面向缓冲区的。**
 *  Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方：
 *  此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓存到一个缓冲区。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70][]

**b、Nio**

*  Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的**缓冲区**，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性：
 *  但是，还需要检查是否该缓冲区中包含所有您需要处理的数据。
 *  而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70 1][]

### （2）、阻塞与非阻塞IO ###

**Java IO的各种流是阻塞的**。这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了：

![20190929173559974.png][]

**Java NIO的非阻塞模式**，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70 2][]

非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。

### （3）、选择器（Selectors） ###

Java NIO的选择器**允许一个单独的线程来监视多个输入通道**，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。这种选择机制，使得一个单独的线程很容易来管理多个通道。

**（4）对于传统IO和NIO，网上有一对图片表达的非常好：**

**a、io**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70 3][]

**大门** 相当于 **ServerSocket**

**客人**相当于 **socket客户端**

**服务员**相当于每个**socket客户端的处理线程**

当在**多线程的情况下**处理客户端的时候，就相当于餐厅**每一个客人都配备了一个专门的服务员**，这不管对系统还是餐厅，都是很大的开销。

**b、NIO**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70 4][]

**大门**相当于 **serverChannel.socket().bind(new InetSocketAddress(10010))**

**客人**相当于 **SocketChannel客户端**

**服务员**相当于**线程和 selector**

只需要**一个服务员就可以服务所有的客人了**，这对于系统或餐厅来说都是一个低开销的事情。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70]: /images/20230809/b53e3f6791d0482e87dbeada7c5f85c9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70 1]: /images/20230809/dd5e6c619e934f9e8c9d4e3c6a7ad4fe.png
[20190929173559974.png]: /images/20230809/f3cbfe5c8fd848aeb0f7deb5a855652e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70 2]: /images/20230809/28c8138f47df4e25b6695337ead8dfcf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70 3]: /images/20230809/48685ecb6be64bf89850b28dbfd5ed97.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70 4]: /images/20230809/981e9cd368a24626942e4b475173cacf.png