BIO、NIO、IO多路复用模型详细介绍&Java NIO 网络编程

王二蛋！

已于 2023-09-14 09:39:30 修改

阅读量3.7k

点赞数 66

分类专栏： Java # 网络编程文章标签： nio java 网络

于 2023-08-01 20:35:25 首次发布

本文链接：https://blog.csdn.net/qq_28314431/article/details/132047951

版权

Java 同时被 2 个专栏收录

35 篇文章 2 订阅

订阅专栏

网络编程

7 篇文章 0 订阅

订阅专栏

文章目录

前言
基本概念
BIO过程
NIO过程
IO多路复用过程
Java NIO编程
- Java NIO 核心概念
- Java NIO 示例
总结

前言

上文介绍了网络编程的基础知识，并基于 Java 编写了 BIO 的网络编程。我们知道 BIO 模型是存在巨大问题的，比如 C10K 问题，其本质就是因其阻塞原因，导致如果想要承受更多的请求就必须有足够多的线程，但是足够多的线程会带来内存占用问题、CPU上下文切换带来的性能问题，从而造成服务端崩溃的现象。怎么解决这一问题呢？优化呗，所以后面就有了NIO、AIO、IO多路复用。本文将对这几个模型详细说明并基于 Java 编写 NIO。

基本概念

I/O阻塞是哪里阻塞、怎么阻塞？先简单了解一些基本概念

用户空间：被分配给用户进程的虚拟地址空间，用来存储用户进程的代码、数据和堆栈等。
内核空间：操作系统的基础，负责管理计算机的硬件资源和提供系统调用接口，同时也是用户空间和硬件之间的桥梁。

在这里插入图片描述

为了保证操作系统的安全性和稳定性，用户进程和操作系统内核是隔离的，用户进程不能直接访问内核空间，而是需要通过系统调用等方式向内核发起请求，由内核代表用户进程执行操作。

也就是说我们的应用程序在向硬件设备，比如网卡、磁盘等读取或写入数据时需要经过内核。下面对BIO、NIO、IO多路复用模型逐一介绍，详细了解各模型IO过程。

BIO过程

首先明确一下，我们所说的IO阻塞是用户进程也就是用户空间中的程序在向硬件设备读取的这个过程，在还没有数据时给用户的反映是需要一直等待的，这个我们叫阻塞IO。过程如下图：
在这里插入图片描述

我们可以看到，在进程向内核发起调用后直到数据返回，整个过程都是阻塞的，结合Java BIO 编程，也就是说在 inputStream.read() 这个过程是阻塞的，就存在几个问题：

由于阻塞会占用当前线程，使之不能进行其他操作，当有新的请求时只能新建线程。在 Linux 系统中，每个线程的默认栈大小为 8MB，在不考虑其他因素的情况下，一个 8G 的服务器最多也就承载1000个请求量。
由于线程数会随着请求量增大而增大，当有大量的线程阻塞唤醒，CPU 频繁的切换上下文会导致性能的下降。

这个问题也就是C10K问题的本质，看上去很直观，使用少的线程就处理多个IO是不是就可以解决呢？继续看NIO过程。

NIO过程

NIO我们说的是非阻塞，通过对BIO的说明，NIO的非阻塞体现在：无论有无数据都直接响应给用户进程，如下图：

在这里插入图片描述

我们可以看到，确实是在用户进程调用recvfrom()函数后直接响应，但是在没有拿到数据之前一直在轮询调用，虽然没有因为阻塞造成CPU上下文的切换，但是CPU一直处于空转状态，不能充分发挥CPU的作用。与BIO一样，在单线程的情况下，只能依次处理IO事件，单个线程依然处理不了多个IO事件。

IO多路复用过程

既然NIO与BIO一样并不能解决因阻塞可能会造成的C10K问题，那如何让一个线程可以处理多个IO事件呢？可不可以这样：用一个线程专门监听这些IO，一旦哪个IO有数据了再去接收数据。IO多路复用就是这个原理，如下图：

在这里插入图片描述

我们可以看到，多了一个select()函数调用，select()会去监听指定的FD（这里注意一下，在Linux中，一切皆文件，包括socket），内核去监听FD对应的sockets。任意一个或多个socket有数据了就返回给select()，这个时候再去调用recvfrom()接收sockets的数据，从而实现了单个线程处理多个I/O操作，提高系统的效率和性能。

在Linux下，常用的I/O多路复用方式有三种：select、poll和epoll。

select和poll的原理是基于轮询，即不断地查询所有注册的I/O事件，如果有事件发生就立即通知应用程序。这种方式的效率较低，因为每次查询都需要遍历所有的I/O事件。
epoll的原理是基于事件通知，即只有当I/O事件发生时，才会通知应用程序。这种方式的效率更高，因为它避免了无效的查询。

Java NIO编程

相比Java BIO编程，Java NIO编程理解起来没有那么直观，不过在理解多个IO模型（尤其是IO多路复用）后就相对容易理解了，Java NIO实际上就是IO多路复用。

Java NIO 核心概念

在Java NIO编程中，有几个核心的概念（组件）需要了解：

通道（Channel）：通道是对原始I/O操作的抽象，可以用于读取和写入数据。它可以与文件、套接字等进行交互。
缓冲区（Buffer）：缓冲区是一个容器，用于存储数据。在进行读写操作时，数据会先被读取到缓冲区中，然后从缓冲区中写入或读取。
选择器（Selector）：选择器是Java NIO提供的一种多路复用机制，可以通过一个线程管理多个通道的I/O操作。

相对于BIO，开发者不直接与Socket交互，而是通过Selector与多个Channel交互，同时Buffer提供了方法来管理缓冲区的容量、位置和限制，通过设置这些属性，可以控制数据的读写位置和范围。总之NIO在提升IO处理效率和性能的同时支持更丰富的功能，

Java NIO 示例

以下是一个简单的Java NIO网络编程示例，用于创建一个基于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;

public class NIOServer {

    private Selector selector;

    public static void main(String[] args) throws IOException {
        NIOServer server = new NIOServer();
        server.startServer();
    }

    public void startServer() throws IOException {
        // 创建Selector
        selector = Selector.open();

        // 创建ServerSocketChannel，并绑定端口
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.socket().bind(new InetSocketAddress(8888));

        // 将ServerSocketChannel注册到Selector上，并监听连接事件。当接收到一个客户端连接请求时就绪。该操作只给服务器使用。
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("Server started on port 8888");

        // 循环等待事件发生
        while (true) {
            // 等待事件触发，阻塞 ｜ selectNow():非阻塞，立刻返回。
            selector.select();

            Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
            while (keys.hasNext()) {
                SelectionKey key = keys.next();
                // 移除当前处理的SelectionKey
                keys.remove();

                if (key.isAcceptable()) {
                    // 处理连接请求
                    handleAccept(key);
                }

                if (key.isReadable()) {
                    // 处理读数据请求
                    handleRead(key);
                }
            }
        }
    }

    private void handleAccept(SelectionKey key) throws IOException {
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
        // 监听到ServerSocketChannel连接事件，获取到连接的客户端
        SocketChannel clientChannel = serverChannel.accept();
        clientChannel.configureBlocking(false);
        // 将clientChannel注册到Selector上，并监听读事件，当操作系统读缓冲区有数据可读时就绪（该客户端的）。
        clientChannel.register(selector, SelectionKey.OP_READ);

        System.out.println("Client connected: " + clientChannel.getRemoteAddress());
    }

    private void handleRead(SelectionKey key) throws IOException {
        SocketChannel clientChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int bytesRead = clientChannel.read(buffer);

        if (bytesRead == -1) {
            // 客户端断开连接
            key.cancel();
            clientChannel.close();
            System.out.println("Client disconnected ");
            return;
        }

        byte[] data = new byte[bytesRead];
        buffer.flip();
        buffer.get(data);

        String message = new String(data).trim();
        System.out.println("Received message from client: " + message);

        // 回复客户端
        String response = "Server response: " + message;
        ByteBuffer responseBuffer = ByteBuffer.wrap(response.getBytes());
        clientChannel.write(responseBuffer);
    }
}

客户端代码：

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.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;

public class NIOClient {
    private Selector selector;
    private SocketChannel socketChannel;

    public static void main(String[] args) {
        NIOClient client = new NIOClient();
        new Thread(() -> client.doConnect("localhost", 8888)).start();
        Scanner scanner = new Scanner(System.in);
        while (true) {
            String message = scanner.nextLine();
            if ("bye".equals(message)) {
                // 如果发送的消息是"bye"，则关闭连接并退出循环
                client.doDisConnect();
                break;
            }
            client.sendMsg(message);
        }

    }

    private void doDisConnect() {
        try {
            socketChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void sendMsg(String message) {
        // 发送消息到服务器
        ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());
        try {
            socketChannel.write(buffer);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void doConnect(String host, int port) {
        try {
            selector = Selector.open();
            // 创建SocketChannel并连接服务器
            socketChannel = SocketChannel.open();
            socketChannel.configureBlocking(false);
            socketChannel.connect(new InetSocketAddress(host, port));
            // 等待连接完成
            while (!socketChannel.finishConnect()) {
                // 连接未完成，可以做一些其他的事情
            }
            socketChannel.register(selector, SelectionKey.OP_READ);
            System.out.println("连接成功！");
            while (true) {
                // 等待事件触发，阻塞 ｜ selectNow():非阻塞，立刻返回。
                selector.select();

                Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
                while (keys.hasNext()) {
                    SelectionKey key = keys.next();
                    // 移除当前处理的SelectionKey
                    keys.remove();
                    if (key.isReadable()) {
                        // 处理读数据请求
                        handleRead(key);
                    }
                }
            }
        } catch (IOException e) {
            System.out.println("连接失败！！！");
            e.printStackTrace();
        }
    }

    private void handleRead(SelectionKey key) throws IOException {
        SocketChannel clientChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int bytesRead = clientChannel.read(buffer);

        if (bytesRead == -1) {
            // 释放资源
            key.cancel();
            clientChannel.close();
            return;
        }

        byte[] data = new byte[bytesRead];
        buffer.flip();
        buffer.get(data);

        String message = new String(data).trim();
        System.out.println("Received message from server: " + message);
    }


}

总结

通过本文介绍，我们可以了解各个IO模型原理，并且对很多概念有了更清晰的认识，比如：
阻塞体现在：用户进程发起系统调用接口后，不论有无数据，是否直接响应结果？如果直接响应就是非阻塞，等待就是阻塞；
IO多路复用原理就是单个线程处理多个I/O操作，从而提高系统的效率和性能；
并且通过对IO多路复用的理解快速的入门了Java NIO 编程。

王二蛋！

关注

66
点赞
踩
77

收藏

觉得还不错? 一键收藏
打赏
67
评论
BIO、NIO、IO多路复用模型详细介绍&Java NIO 网络编程

上文介绍了网络编程的基础知识，并基于 Java 编写了 BIO 的网络编程。我们知道 BIO 模型是存在巨大问题的，比如 C10K 问题，其本质就是因其阻塞原因，导致如果想要承受更多的请求就必须有足够多的线程，但是足够多的线程会带来内存占用问题、CPU上下文切换带来的性能问题，从而造成服务端崩溃的现象。怎么解决这一问题呢？优化呗，所以后面就有了NIO、AIO、IO多路复用。本文将对这几个模型详细说明并基于 Java 编写 NIO。
复制链接

扫一扫