Netty - I/O模型之NIO

心已赠人 2023-01-07 10:14 70阅读 0赞

### 文章目录 ###

*  Non Blocking I/O 同步非阻塞模型
 *  Code
 *   *  Server
     *  Client
     *  日志及需要优化的地方
     *  优化 （多路复用器）
 *  小结

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70]

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

# Non Blocking I/O 同步非阻塞模型 #

同步非阻塞

**一个线程可以处理多个请求(连接)**，客户端发送的连接请求都会注册到**多路复用器selector**上，多路复用器轮询到连接有IO请求就进行处理。

JDK1.4开始引入

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

# Code #

## Server ##

package com.artisan.iomodel.nio;
    
    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.nio.ByteBuffer;
    import java.nio.channels.ServerSocketChannel;
    import java.nio.channels.SocketChannel;
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    /** * @author 小工匠 * @version 1.0 * @description: TODO * @date 2021/1/17 0:06 * @mark: show me the code , change the world */
    
    public class NioServer { 
    
        // 保存客户端连接
        static List<SocketChannel> channelList = new ArrayList<>();
    
        public static void main(String[] args) throws IOException { 
    
            // 创建NIO ServerSocketChannel,与BIO的serverSocket类似
            ServerSocketChannel serverSocket = ServerSocketChannel.open();
            serverSocket.socket().bind(new InetSocketAddress(7777));
            // 设置ServerSocketChannel为非阻塞
            serverSocket.configureBlocking(false);
            System.out.println("服务启动成功");
    
            while (true) { 
                // 非阻塞模式accept方法不会阻塞，否则会阻塞
                // NIO的非阻塞是由操作系统内部实现的，底层调用了linux内核的accept函数
                SocketChannel socketChannel = serverSocket.accept();
                if (socketChannel != null) {  // 如果有客户端进行连接
                    System.out.println("连接成功");
                    // 设置SocketChannel为非阻塞
                    socketChannel.configureBlocking(false);
                    // 保存客户端连接在List中
                    channelList.add(socketChannel);
                }
                // 遍历连接进行数据读取
                Iterator<SocketChannel> iterator = channelList.iterator();
                while (iterator.hasNext()) { 
                    SocketChannel sc = iterator.next();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(128);
                    // 非阻塞模式read方法不会阻塞，否则会阻塞
                    int len = sc.read(byteBuffer);
                    // 如果有数据，把数据打印出来
                    if (len > 0) { 
                        System.out.println("接收到消息：" + new String(byteBuffer.array()));
                    } else if (len == -1) {  // 如果客户端断开，把socket从集合中去掉
                        iterator.remove();
                        System.out.println("客户端断开连接");
                    }
                }
            }
        }
    }

## Client ##

我们用cmd工具来连一下 ， `telnet 127.0.0.1 7777`

![在这里插入图片描述][20210116230629533.png]

回车，输入 `ctrl + ]`

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 1]

发送消息

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 2]

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

## 日志及需要优化的地方 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 3]

举个例子，如果连接数太多的话，会有大量的无效遍历，假如有1万个连接，其中只有1000个连接有写数据，但是由于其他9000个连接并没有断开，我们还是要每次轮询遍历一万次，其中有十分之九的遍历都是无效的…是不是有点不妥当呢？

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

## 优化 （多路复用器） ##

为了优化这个问题 ， NIO引入多路复用器

package com.artisan.iomodel.nio;
    
    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;
    import java.util.Set;
    /** * @author 小工匠 * @version 1.0 * @description: TODO * @date 2021/1/17 0:50 * @mark: show me the code , change the world */
    public class NioSelectorServer { 
    
    
        public static void main(String[] args) throws IOException, InterruptedException { 
    
            // 创建NIO ServerSocketChannel
            ServerSocketChannel serverSocket = ServerSocketChannel.open();
            serverSocket.socket().bind(new InetSocketAddress(7777));
            // 设置ServerSocketChannel为非阻塞
            serverSocket.configureBlocking(false);
            // 打开Selector处理Channel，即创建epoll
            Selector selector = Selector.open();
            // 把ServerSocketChannel注册到selector上，并且selector对客户端accept连接操作感兴趣
            serverSocket.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("服务启动成功");
    
            while (true) { 
                // 阻塞等待需要处理的事件发生
                selector.select();
    
                // 获取selector中注册的全部事件的 SelectionKey 实例
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
    
                // 遍历SelectionKey对事件进行处理
                while (iterator.hasNext()) { 
                    SelectionKey key = iterator.next();
                    // 如果是OP_ACCEPT事件，则进行连接获取和事件注册
                    if (key.isAcceptable()) { 
                        ServerSocketChannel server = (ServerSocketChannel) key.channel();
                        SocketChannel socketChannel = server.accept();
                        socketChannel.configureBlocking(false);
                        // 这里只注册了读事件，如果需要给客户端发送数据可以注册写事件
                        socketChannel.register(selector, SelectionKey.OP_READ);
                        System.out.println("客户端连接成功");
                    } else if (key.isReadable()) {   // 如果是OP_READ事件，则进行读取和打印
                        SocketChannel socketChannel = (SocketChannel) key.channel();
                        ByteBuffer byteBuffer = ByteBuffer.allocate(128);
                        int len = socketChannel.read(byteBuffer);
                        // 如果有数据，把数据打印出来
                        if (len > 0) { 
                            System.out.println("接收到消息：" + new String(byteBuffer.array()));
                        } else if (len == -1) {  // 如果客户端断开连接，关闭Socket
                            System.out.println("客户端断开连接");
                            socketChannel.close();
                        }
                    }
                    //从事件集合里删除本次处理的key，防止下次select重复处理
                    iterator.remove();
                }
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 4]

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

# 小结 #

NIO方式适用于连接数目多且连接比较短（轻操作） 的架构， 比如聊天服务器， 弹幕系统， 服务器间通讯，但编程比较复杂

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70]: /images/20221119/1196ceaddc7b4a1994aed8a878c2f325.png
[20210116230629533.png]: /images/20221119/dc290d47dd474362ba8a4af0d4946ca1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 1]: /images/20221119/91e67e68ddd7426da536b6f00ebb0c4c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 2]: /images/20221119/322b47ecb40742ebae48e2905e7124c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 3]: /images/20221119/556c92934a144d6295f8641e7b6ed10d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 4]: /images/20221119/fcac1607ab5d481bba447b4839c3baa2.png