1. 什么是 I/O？为什么模型重要？

简单来说，I/O（Input/Output）就是数据在内存（你的程序）和外部设备（如磁盘、网络、另一台主机等）之间的流动过程。

核心问题： CPU 和内存的速度远高于外部设备。当一个线程向磁盘或网络请求数据时，如果该线程一直等待数据准备就绪，什么也不做，就会造成巨大的 CPU 资源浪费。I/O 模型就是为了解决 “如何等待数据准备” 和 “数据如何从内核拷贝到用户空间” 这两个问题而提出的不同解决方案。

无论使用哪种 I/O 模型，一次完整的数据传输（例如一次 socket.read()）都包含两个关键阶段：

1. 等待数据就绪 (Waiting for the data to be ready)：数据从网络（客户端）传输到服务器内核的缓冲区需要时间。内核需要等待数据包到达、校验、并准备好。

2. 将数据从内核拷贝到用户空间 (Copying the data from the kernel to user space)：数据到达内核缓冲区后，应用程序需要调用系统调用（如 read）将数据从内核缓冲区拷贝到应用程序自己分配的内存（用户空间）中，才能进行处理。

不同 I/O 模型的根本区别就在于应用程序在这两个阶段中的行为方式。

---

2. Java 中现有的主要 I/O 模型

Java 主要支持三种 I/O 模型：

1. BIO (Blocking I/O)：同步阻塞 I/O

2. NIO (Non-blocking I/O / New I/O)：同步非阻塞 I/O

3. AIO (Asynchronous I/O)：异步非阻塞 I/O

“同步/异步”和“阻塞/非阻塞”是两组概念，经常被混淆。

• 同步 vs 异步： 关注的是消息通信机制。

  • 同步： 调用发出后，调用者必须主动等待结果返回。

  • 异步： 调用发出后，调用者不必立刻等待结果，结果准备好后通过回调函数、信号等机制通知调用者。

• 阻塞 vs 非阻塞： 关注的是程序在等待调用结果时的状态。

  • 阻塞： 调用结果返回前，当前线程会被挂起，不能做其他事情。

  • 非阻塞： 调用结果返回前，该线程可以继续处理其他任务。

---

模型一：BIO (同步阻塞 I/O)

原理

这是最传统的一种 I/O 模型。其工作模式是：一个连接对应一个线程。
当应用程序调用 read() 等 I/O 操作时，线程会一直阻塞，直到内核将数据准备好，并且数据从内核空间拷贝到用户空间，整个过程才结束。

BIO 模型在两个阶段都是阻塞的。

流程图简化为：

1. 线程发起 read 调用。

2. 内核等待数据就绪。（线程阻塞）

3. 数据就绪，从内核拷贝到用户空间。（线程依然阻塞）

4. 拷贝完成，read 调用返回，线程继续执行。

服务器端工作流程：

1. 服务器线程调用 InputStream.read()（或类似的读取方法）。

2. 该调用会导致系统调用 read()，线程从用户态进入内核态。

3. 内核阶段1（等待数据就绪）：内核发现套接字接收缓冲区中没有数据，线程阻塞，等待客户端发送的数据经过网卡、内核协议栈，最终到达内核的接收缓冲区。

4. 内核阶段2（拷贝数据）：客户端数据到达后，内核将数据从它的缓冲区拷贝到 read() 调用时指定的用户空间缓冲区（即你的 byte[] 数组）。

5. 拷贝完成后，read() 系统调用返回，线程从内核态切换回用户态，并继续执行后续代码。

整个过程，服务器线程就像在“干等”，什么也做不了，直到数据完整地拷贝到它的内存中。

代码示例 (模拟服务器端)

// 简化代码，忽略异常处理
public class BioServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        while (true) {
            // 1. 阻塞accept()，直到有客户端连接
            Socket clientSocket = serverSocket.accept();
            System.out.println("客户端连接: " + clientSocket.getInetAddress());

            // 2. 为每个客户端创建一个新线程进行处理
            new Thread(() -> {
                try {
                    InputStream input = clientSocket.getInputStream();
                    BufferedReader reader = new BufferedReader(new InputStreamReader(input));
                    String requestData;
                    // 3. 阻塞readLine()，直到读取到一行数据
                    while ((requestData = reader.readLine()) != null) {
                        System.out.println("收到数据: " + requestData);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

代码视角

// 服务器端线程代码 (BIO)
Socket clientSocket = serverSocket.accept(); // 阻塞等待连接
InputStream in = clientSocket.getInputStream();
byte[] buffer = new byte[1024];

// 下面这行代码体现了两个阶段的阻塞：
int bytesRead = in.read(buffer); // 1. 阻塞等待数据到达内核
                                 // 2. 阻塞等待数据从内核拷贝到用户空间（buffer数组）
// 只有当数据完全拷贝到buffer后，代码才会继续执行
String data = new String(buffer, 0, bytesRead);
System.out.println("收到: " + data);

特点：一个线程服务一个连接，连接期间线程被独占，效率极低。

应用场景

• 连接数少且固定的架构：代码简单，易于理解和调试。

• JDK 1.4 之前唯一的选择。

缺点

• 资源消耗大：每个连接都需要一个独立的线程，线程本身占用内存，线程上下文切换开销大。

• 并发能力低：当连接数成千上万时，无法创建那么多线程，服务器压力巨大。

---

模型二：NIO (同步非阻塞 I/O / New I/O)

原理

NIO 的核心是轮询和事件驱动。它解决了第一个阶段（等待数据就绪）的阻塞问题。

Java 1.4 引入，旨在解决 BIO 的性能瓶颈。其核心是 “一个线程处理多个连接”。

它有三个关键组件：

1. Channel (通道)：替代了 BIO 中的 Stream，是双向的（可读可写），支持异步 I/O 操作。常见的有 ServerSocketChannel (服务器监听) 和 SocketChannel (TCP 客户端)。

2. Buffer (缓冲区)：一个容器对象，所有数据的读写都必须通过 Buffer。它提供了结构化访问数据的方法。

3. Selector (选择器)：NIO 的灵魂。一个 Selector 可以轮询多个 Channel。当一个 Channel 上有事件（如连接建立、数据可读、数据可写）发生时，Selector 会通知应用程序，然后由应用程序处理这些事件。

这种模型被称为 I/O 多路复用（I/O Multiplexing），如 select, poll, epoll（Linux）。Java NIO 在底层使用了操作系统的这些机制。

服务器端工作流程 (以 Selector 为例)：

1. 服务器将 SocketChannel 配置为非阻塞模式 (configureBlocking(false)) 并注册到 Selector，关心 OP_READ 事件。

2. 主线程调用 Selector.select()，阻塞等待任何一个注册的 Channel 上有事件就绪（如可读）。

3. 当客户端数据到达内核缓冲区后，内核会通知 Selector。select() 方法返回。

4. 服务器遍历就绪的 SelectionKey，发现一个 OP_READ 事件。

5. 服务器调用 channel.read(buffer)。

   • 注意：此时数据已经在内核缓冲区准备好了（因为 OP_READ 事件就绪意味着第1阶段已完成）。所以这个 read() 调用直接进入第二阶段：将数据从内核空间拷贝到用户空间的 ByteBuffer。

   • 这个拷贝过程是同步的，线程会等待拷贝完成。但因为数据量通常不大，这个过程非常快。

6. 拷贝完成，read() 返回读取的字节数，服务器处理数据。

关键改进：Selector 的 select() 阻塞代替了每个 socket 的 read() 阻塞。一个线程可以管理成千上万个连接，只在“有活干”（数据确实到了）的时候才去调用 read() 进行拷贝，极大提高了线程利用率。

代码示例 (服务器端)

public class NioServer {
    public static void main(String[] args) throws IOException {
        // 1. 创建Selector
        Selector selector = Selector.open();
        // 2. 创建Channel并设置为非阻塞模式
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.socket().bind(new InetSocketAddress(8080));
        // 3. 将Channel注册到Selector，关注ACCEPT事件
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {
            // 4. 阻塞，等待就绪的事件
            selector.select();
            // 5. 获取就绪的SelectionKey集合
            Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();

            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();
                keyIterator.remove(); // 处理完后移除

                if (key.isAcceptable()) {
                    // 处理ACCEPT事件
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel clientChannel = server.accept();
                    clientChannel.configureBlocking(false);
                    // 将新连接注册到Selector，关注READ事件
                    clientChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println("客户端连接: " + clientChannel.getRemoteAddress());
                } else if (key.isReadable()) {
                    // 处理READ事件
                    SocketChannel clientChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int bytesRead = clientChannel.read(buffer);
                    if (bytesRead > 0) {
                        buffer.flip(); // 切换为读模式
                        byte[] data = new byte[buffer.remaining()];
                        buffer.get(data);
                        String message = new String(data);
                        System.out.println("收到数据: " + message);
                    } else if (bytesRead < 0) {
                        // 对方关闭连接
                        key.cancel();
                        clientChannel.close();
                    }
                }
            }
        }
    }
}

代码视角

// 之前已经将clientChannel注册到selector，关注OP_READ
if (key.isReadable()) { // 事件就绪：意味着“数据已在内核缓冲区准备好”（阶段1完成）
    SocketChannel channel = (SocketChannel) key.channel();
    ByteBuffer buffer = ByteBuffer.allocate(1024);

    // 下面的read()调用只负责阶段2：将数据从内核拷贝到用户空间（ByteBuffer）
    int bytesRead = channel.read(buffer); 

    if (bytesRead > 0) {
        buffer.flip();
        byte[] data = new byte[buffer.remaining()];
        buffer.get(data);
        System.out.println("收到: " + new String(data));
    }
}

特点：第一阶段非阻塞（通过事件通知），第二阶段阻塞（同步拷贝）。“I/O多路复用”这个名称正是指用同一个Selector线程管理了多个I/O通道。

应用场景

• 高并发、连接数多且连接时间短（轻操作）的场景：如聊天服务器、弹幕系统、游戏服务器。

• 任何需要管理成千上万个客户端连接的应用。

优点

• 单线程可以处理大量连接，极大地减少了线程上下文切换的开销。

• 资源占用相对 BIO 大大减少。

缺点

• 编程模型复杂，对开发者要求高。

• 虽然是非阻塞 I/O，但 Selector.select() 本身是阻塞的，并且数据的读写（从内核到用户空间的拷贝）过程仍然是同步的。

---

模型三：AIO (异步非阻塞 I/O)

原理

Java 1.7 引入，也称为 NIO.2。AIO 的理念是 “订阅-通知” 模式。

应用程序发起一个 I/O 操作（如 read）后，会立刻返回，可以去做别的事情。当内核完成所有操作（包括数据准备和从内核空间到用户空间的拷贝）后，会主动通知应用程序：“你的数据已经准备好了，在这里，你来处理吧”。

这实现了真正的异步。“同步”和“异步”的区别就在于数据拷贝阶段是否需要进程自己参与。NIO 在数据就绪后，仍需线程自己调用 read 方法进行拷贝（同步），而 AIO 则是由操作系统完成拷贝后再通知（异步）。

AIO 主要使用 AsynchronousServerSocketChannel 和 AsynchronousSocketChannel，并通过 CompletionHandler 回调接口来处理成功或失败的结果。

AIO 是真正的异步。它的目标是让应用程序在两个阶段都不需要阻塞。

服务器端工作流程：

1. 服务器调用异步的 read() 方法（如 AsynchronousSocketChannel.read()），并传入一个回调函数 (CompletionHandler)。

2. 这个调用会立即返回，服务器线程可以立刻去处理其他任务，完全不会阻塞。

3. 内核开始自行工作：

   • 内核阶段1：等待数据到达其缓冲区。

   • 内核阶段2：数据到达后，内核自己负责将数据从内核缓冲区拷贝到应用程序在调用 read() 时提供的 ByteBuffer（用户空间）。

4. 当整个过程（等待+拷贝）全部完成后，内核会通知应用程序。操作系统会调度一个线程（可能是另一个工作线程）去执行你之前设置的回调函数 completed()，在这个函数里，数据已经安静地躺在 ByteBuffer 里 ready 了。

这是最理想的模式：应用程序发起调用后就不再关心具体过程，直到收到“搞定”的通知。

代码示例 (服务器端)

public class AioServer {
    public static void main(String[] args) throws IOException, InterruptedException {
        AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open()
                .bind(new InetSocketAddress(8080));

        // 1. 接收连接，传入一个CompletionHandler回调对象
        serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
            @Override
            public void completed(AsynchronousSocketChannel clientChannel, Object attachment) {
                // 成功接收到一个连接
                serverChannel.accept(null, this); // 继续接收下一个连接，重要！
                System.out.println("客户端连接: " + clientChannel);

                ByteBuffer buffer = ByteBuffer.allocate(1024);
                // 2. 异步读取数据，也传入一个CompletionHandler
                clientChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                    @Override
                    public void completed(Integer result, ByteBuffer attachment) {
                        // 读取数据成功
                        attachment.flip();
                        byte[] data = new byte[attachment.remaining()];
                        attachment.get(data);
                        String message = new String(data);
                        System.out.println("收到数据: " + message);
                        // 可以继续异步读取下一条消息
                        clientChannel.read(buffer, buffer, this);
                    }

                    @Override
                    public void failed(Throwable exc, ByteBuffer attachment) {
                        exc.printStackTrace();
                    }
                });
            }

            @Override
            public void failed(Throwable exc, Object attachment) {
                exc.printStackTrace();
            }
        });

        // 主线程不能退出，因为AIO是异步的，守护线程在工作
        Thread.currentThread().join();
    }
}

代码视角

// 服务器端代码 (AIO)
ByteBuffer buffer = ByteBuffer.allocate(1024);

// 发起异步读取操作。调用立即返回，线程不会阻塞。
channel.read(buffer, null, new CompletionHandler<Integer, Object>() {
    @Override
    public void completed(Integer result, Object attachment) {
        // 回调函数：当内核完成【等待数据】和【拷贝数据】后，会调用此方法
        // 此时数据已经在你提供的buffer里了
        buffer.flip();
        byte[] data = new byte[buffer.remaining()];
        buffer.get(data);
        System.out.println("收到: " + new String(data));
        // 处理数据...
    }

    @Override
    public void failed(Throwable exc, Object attachment) {
        // 处理错误
    }
});

// 调用read后，代码立刻继续执行，可以做其他事情
System.out.println("异步read调用已发起，主线程继续执行...");

特点：应用程序在两个阶段都不阻塞，“你好了叫我一声就行”。

应用场景

• 连接数多且连接时间长（重操作）的场景：适用于文件 I/O 操作或需要大量计算的场景，能充分发挥异步操作的优势，避免线程被长时间阻塞。

优点

• 真正的异步，性能理论上最高。

• 不会阻塞调用线程。

缺点

• 编程模型最复杂（回调地狱）。

• Linux 对 AIO 的支持不够完善，其底层实现可能仍使用 epoll 模拟，性能提升不如在 Windows 上明显。因此在实际生产中，AIO 的使用远没有 NIO 广泛。

---

总结与对比

特性	BIO	NIO	AIO
全称	Blocking I/O	Non-blocking I/O / New I/O	Asynchronous I/O
编程模型	一个连接一个线程	一个线程处理多个连接（Selector）	订阅-通知（回调）
阻塞类型	同步阻塞	同步非阻塞（多路复用）	异步非阻塞
吞吐量	低	高	理论上最高
复杂度	低	高	最高
可靠性	高	高	高（但Linux支持弱）
适用场景	连接数少、固定	高并发、短连接	高并发、长连接、重操作

现实应用

• Tomcat 8+：默认使用 NIO 模型来处理 HTTP 请求，以支持更高的并发。

• Netty：一个广受欢迎的 Java NIO 客户端/服务器框架。它极大地简化了 NIO 的开发，提供了更高级的 API，并解决了 NIO 的一些固有缺陷（如空轮询 bug）。绝大多数高性能网络应用（如Dubbo、RocketMQ、gRPC）的底层通信都是基于 Netty 构建的。它通常比直接使用 Java 原生的 NIO 或 AIO 是更好的选择。