同步非阻塞IO模型

小咪咪 2023-10-02 17:18 37阅读 0赞

## 同步非阻塞IO模型 ##

有上上篇`IO`模型中的，同步非阻塞`IO`模型，我们能够知道，用户线程一直发送请求，内核一直都能都够返回 ，直到内核完成准备数据、数据拷贝的工作。并且返回成功的指示。在此过程中用户线程不是阻塞的状态

### 实现 ###

使用`java`来实现同步非阻塞`IO`模型，即我们所说的`NIO`的模型

#### 客户端实现 ####

/**
     * @author:triumphxx
     * @Date:2021/11/12
     * @Time:11:03 下午
     * @微信公众号：北漂码农有话说
     * @网站：http://blog.triumphxx.com.cn
     * @GitHub https://github.com/triumphxx
     * @Desc: NIO编程模型客户端
     **/
    public class NIOClient {
        
        // 通道管理器(Selector)
        private static Selector selector;
    
        public static void main(String[] args) throws IOException {
        
            // 创建通道管理器(Selector)
            selector = Selector.open();
            // 创建通道SocketChannel
            SocketChannel channel = SocketChannel.open();
            // 将通道设置为非阻塞
            channel.configureBlocking(false);
            // 客户端连接服务器，其实方法执行并没有实现连接，需要在handleConnect方法中调channel.finishConnect()才能完成连接
            channel.connect(new InetSocketAddress("localhost", 9090));
            /**
             * 将通道(Channel)注册到通道管理器(Selector)，并为该通道注册selectionKey.OP_CONNECT
             * 注册该事件后，当事件到达的时候，selector.select()会返回，
             * 如果事件没有到达selector.select()会一直阻塞。
             */
            channel.register(selector, SelectionKey.OP_CONNECT);
            // 循环处理
            while (true) {
        
                /*
                 * 选择一组可以进行I/O操作的事件，放在selector中，客户端的该方法不会阻塞，
                 * selector的wakeup方法被调用，方法返回，而对于客户端来说，通道一直是被选中的
                 * 这里和服务端的方法不一样，查看api注释可以知道，当至少一个通道被选中时。
                 */
                selector.select();
                // 获取监听事件
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                // 迭代处理
                while (iterator.hasNext()) {
        
                    // 获取事件
                    SelectionKey key = iterator.next();
                    // 移除事件，避免重复处理
                    iterator.remove();
                    // 检查是否是一个就绪的已经连接服务端成功事件
                    if (key.isConnectable()) {
        
                        handleConnect(key);
                    } else if (key.isReadable()) {
        // 检查套接字是否已经准备好读数据
                        handleRead(key);
                    }
                }
            }
        }
    
        /**
         * 处理客户端连接服务端成功事件
         */
        private static void handleConnect(SelectionKey key) throws IOException {
        
            // 获取与服务端建立连接的通道
            SocketChannel channel = (SocketChannel) key.channel();
            if (channel.isConnectionPending()) {
        
                // channel.finishConnect()才能完成连接
                channel.finishConnect();
            }
            channel.configureBlocking(false);
            // 数据写入通道
            String msg = "Hello Server!";
            channel.write(ByteBuffer.wrap(msg.getBytes()));
            // 通道注册到选择器，并且这个通道只对读事件感兴趣
            channel.register(selector, SelectionKey.OP_READ);
        }
    
        /**
         * 监听到读事件，读取客户端发送过来的消息
         */
        private static void handleRead(SelectionKey key) throws IOException {
        
            SocketChannel channel = (SocketChannel) key.channel();
            //开辟堆内缓冲区
            ByteBuffer buffer = ByteBuffer.allocate(128);
            // 从通道读取数据到缓冲区
            channel.read(buffer);
            // 输出服务端响应发送过来的消息
            byte[] data = buffer.array();
            String msg = new String(data).trim();
            System.out.println("服务端发来的消息：" + msg);
        }
    
    }

> 由客户端的代码可以知道：首先我们将 `select` 打开，然后创建通道、将通道设置为非阻塞、创建连接、完成注册 等待监听、处理事件，详细的每一行代码的意思，都已经进展标注。看代码即可。

#### 服务端实现 ####

**
     * @author:triumphxx
     * @Date:2021/11/12
     * @Time:11:03 下午
     * @微信公众号：北漂码农有话说
     * @网站：http://blog.triumphxx.com.cn
     * @GitHub https://github.com/triumphxx
     * @Desc: NIO编程模型服务端
     **/
    public class NIOServer {
        
    
        // 通道管理器(Selector)
        private static Selector selector;
    
        public static void main(String[] args) throws IOException {
        
            // 创建通道管理器(Selector)
            selector = Selector.open();
            // 创建通道ServerSocketChannel
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            // 将通道设置为非阻塞
            serverSocketChannel.configureBlocking(false);
            // 将ServerSocketChannel对应的ServerSocket绑定到指定端口(port)
            ServerSocket serverSocket = serverSocketChannel.socket();
            serverSocket.bind(new InetSocketAddress(9090));
            /**
             * 将通道(Channel)注册到通道管理器(Selector)，并为该通道注册selectionKey.OP_ACCEPT事件
             * 注册该事件后，当事件到达的时候，selector.select()会返回，
             * 如果事件没有到达selector.select()会一直阻塞。
             */
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            // 循环处理
            while (true) {
        
                // 当注册事件到达时，方法返回，否则该方法会一直阻塞
                selector.select();
                // 获取监听事件
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                // 迭代处理
                while (iterator.hasNext()) {
        
                    // 获取事件
                    SelectionKey key = iterator.next();
                    // 移除事件，避免重复处理
                    iterator.remove();
                    // 检查是否是一个就绪的可以被接受的客户端请求连接
                    if (key.isAcceptable()) {
        
                        handleAccept(key);
                    } else if (key.isReadable()) {
        // 检查套接字是否已经准备好读数据
                        handleRead(key);
                    }
                }
            }
        }
    
        /**
         * 处理客户端连接成功事件
         */
        private static void handleAccept(SelectionKey key) throws IOException {
        
            // 获取客户端连接通道
            ServerSocketChannel server = (ServerSocketChannel) key.channel();
            SocketChannel socketChannel = server.accept();
            socketChannel.configureBlocking(false);
            // 信息通过通道发送给客户端
            String msg = "Hello Client!";
            socketChannel.write(ByteBuffer.wrap(msg.getBytes()));
            // 给通道设置读事件，客户端监听到读事件后，进行读取操作
            socketChannel.register(selector, SelectionKey.OP_READ);
        }
    
    
        /**
         * 监听到读事件，读取客户端发送过来的消息
         */
        private static void handleRead(SelectionKey key) throws IOException {
        
            SocketChannel channel = (SocketChannel) key.channel();
            // 从通道读取数据到缓冲区
            ByteBuffer buffer = ByteBuffer.allocate(128);
            channel.read(buffer);
            // 输出客户端发送过来的消息
            byte[] data = buffer.array();
            String msg = new String(data).trim();
            System.out.println("server received msg from client：" + msg);
        }
    }

> 有服务端的代码可以知道：首先我们将 `select` 打开，然后创建通道、将通道设置为非阻塞、创建连接、完成注册 等待监听、处理事件，详细的每一行代码的意思，都已经进展标注。看代码即可。

#### 优点及缺点 ####

优点：可靠性高，吞吐量比较高、非阻塞 缺点：编程模型做复杂

#### 适用场景 ####

适用于连接比较多且连接比较短的场景。比如聊天室！

### 小结 ###

以上就是`java`的`NIO`编程模型，很简单的一个小例子，希望对你有所帮助。[代码传送门][Link 1]

![E6_89_AB_E7_A0_81_E6_90_9C_E7_B4_A2_E8_81_94_E5_90_88_E4_BC_A0_E6_92_AD_E6_A0_B7_E5_BC_8F-_E6_A0_87_E5_87_86_E8_89_B2_E7_89_88.png][]

[Link 1]: https://github.com/triumphxx/learning/tree/master/net-model
[E6_89_AB_E7_A0_81_E6_90_9C_E7_B4_A2_E8_81_94_E5_90_88_E4_BC_A0_E6_92_AD_E6_A0_B7_E5_BC_8F-_E6_A0_87_E5_87_86_E8_89_B2_E7_89_88.png]: http://cdn.triumphxx.com.cn/img/%E6%89%AB%E7%A0%81_%E6%90%9C%E7%B4%A2%E8%81%94%E5%90%88%E4%BC%A0%E6%92%AD%E6%A0%B7%E5%BC%8F-%E6%A0%87%E5%87%86%E8%89%B2%E7%89%88.png