BIO、NIO 和 AIO

概览：什么是 I/O 模型？

I/O（Input/Output）模型定义了程序如何与外部设备（如磁盘、网络）进行数据交互。核心问题在于：当程序发起一个 I/O 请求（比如读取一个文件或接收网络数据）时，如果数据还没准备好，程序该怎么办？

BIO、NIO 和 AIO 代表了三种不同的处理策略，它们在阻塞行为、线程模型、编程复杂度和性能上有显著差异。

1. BIO (Blocking I/O) - 阻塞 I/O

这是最传统、最直观的 I/O 模型，在 Java 早期版本（1.4 之前）中是唯一的 I/O 方式。

核心思想

“一个连接，一个线程”。当一个线程执行一个 I/O 操作时，如果数据没有准备好（例如，调用 read() 方法，但对方还没发送数据），该线程会被阻塞，直到数据到达并被读取到内存中。在此期间，这个线程什么也做不了，只能干等着。

工作流程

1. 创建 ServerSocket，监听指定端口。
2. 调用 accept()：等待客户端连接。这个方法是阻塞的，直到有客户端连接进来，它才会返回一个代表该连接的 Socket 对象。
3. 为新的连接创建一个新线程。
4. 在新线程中，调用 InputStream.read()：读取客户端发送的数据。这个方法也是阻塞的，直到客户端发送了数据，线程才会继续执行。
5. 处理数据，并可能调用 OutputStream.write() 发送响应。write() 方法在某些情况下也可能是阻塞的（例如，操作系统缓冲区已满）。

示例

// 服务器端
ServerSocket serverSocket = new ServerSocket(8080);
while (true) {
    // 1. 阻塞等待连接
    Socket clientSocket = serverSocket.accept(); 
    // 2. 为每个连接创建一个新线程
    new Thread(() -> {
        try {
            BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            // 3. 阻塞读取数据
            String line;
            while ((line = in.readLine()) != null) {
                // 处理数据
                System.out.println("Received: " + line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }).start();
}

优缺点

适用场景

连接数非常少，且对性能要求不高的简单应用。例如，一些内部工具或教学示例。不适合高并发、高吞吐量的生产环境。

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

从 Java 1.4 开始引入，旨在解决 BIO 的性能问题。它提供了一套全新的 I/O API，位于 java.nio 包下。

核心思想

“一个线程，管理多个连接”。NIO 的核心是 多路复用 的思想。它允许单个线程去监视多个 I/O 通道（Channel），当任何一个通道准备好进行 I/O 操作（例如，有数据可读、可以写入数据）时，线程才会去处理它，否则线程可以去做其他事情，而不会被阻塞。

核心组件

1. Channel (通道)：双向的，既可以读也可以写。类似于 BIO 中的 Stream，但更底层。所有数据都通过 Buffer 对象来处理。
2. Buffer (缓冲区)：一个容器对象，包含一些要写入或读出的数据。NIO 是面向缓冲区的，数据总是从通道读入缓冲区，或从缓冲区写入通道。这提供了更灵活的数据操作。
3. Selector (选择器)：NIO 的核心！它是“多路复用器”。一个 Selector 线程可以同时注册多个 Channel。Selector 会不断地轮询这些注册的 Channel，看哪个 Channel 上有事件发生（如连接就绪、读就绪、写就绪）。当有事件发生时，Selector 会将对应的 Channel 放入“就绪键集合”中，然后我们就可以通过 Selector.selectedKeys() 获取这些就绪的 Channel 并进行处理。

工作流程（Reactor 模式）

1. 创建一个 Selector。
2. 创建一个 ServerSocketChannel，并将其配置为非阻塞模式。
3. 将 ServerSocketChannel 注册到 Selector 上，并监听 OP_ACCEPT 事件。
4. 在一个循环中调用 selector.select()。这个方法是阻塞的，但它会阻塞整个 Selector 线程，直到至少有一个已注册的通道发生了感兴趣的事件。
5. select() 返回后，获取“已选择的键集合”（selectedKeys）。
6. 遍历这个集合，对每个键：
   • 如果是 OP_ACCEPT 事件，接受连接，得到 SocketChannel，将其也设置为非阻塞，并注册到同一个 Selector 上，监听 OP_READ 事件。
   • 如果是 OP_READ 事件，从对应的 SocketChannel 中读取数据到 Buffer 进行处理。
   • 如果是 OP_WRITE 事件，将 Buffer 中的数据写入 SocketChannel。

示例

// 1. 创建 Selector 和 ServerSocketChannel
Selector selector = Selector.open();
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.configureBlocking(false); // 设置为非阻塞

// 2. 注册到 Selector，监听 ACCEPT 事件
serverChannel.register(selector, SelectionKey.OP_ACCEPT);

while (true) {
    // 3. 阻塞等待事件发生
    selector.select(); 
    Set<SelectionKey> selectedKeys = selector.selectedKeys();
    Iterator<SelectionKey> iter = selectedKeys.iterator();

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

        if (key.isAcceptable()) {
            // 处理连接
            SocketChannel clientChannel = serverChannel.accept();
            clientChannel.configureBlocking(false);
            clientChannel.register(selector, SelectionKey.OP_READ);
        } else if (key.isReadable()) {
            // 处理读取
            SocketChannel clientChannel = (SocketChannel) key.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int bytesRead = clientChannel.read(buffer);
            // ... 处理数据 ...
        }
    }
}

优缺点

适用场景

高并发服务器，如聊天服务器、游戏服务器、HTTP 服务器等。Netty、Mina 等高性能网络框架都是基于 NIO 模型构建的。

3. AIO (Asynchronous I/O) - 异步 I/O

从 Java 7 开始引入，也被称为 NIO.2，是 I/O 模型的终极形态。

核心思想

“你告诉我结果，别让我等”。AIO 是真正的异步非阻塞 I/O。当应用程序发起一个 I/O 操作时，它会立即返回，并且操作系统会在后台完整地执行这个 I/O 操作（包括将数据从内核拷贝到用户空间）。当操作完成后，操作系统会通知应用程序，或者调用应用程序事先指定的回调函数。

在 NIO 中，线程需要自己从内核缓冲区将数据拷贝到用户缓冲区（channel.read(buffer)），这个拷贝过程是同步的。而在 AIO 中，连这个拷贝过程都由操作系统在后台完成。

工作流程

1. 创建一个 AsynchronousServerSocketChannel。
2. 调用 accept() 方法时，传入一个 CompletionHandler 回调对象。这个方法会立即返回。
3. 当有新的客户端连接时，操作系统会自动调用 CompletionHandler 的 completed 方法，并将代表新连接的 AsynchronousSocketChannel 传给你。
4. 在 completed 方法中，你可以继续调用 read() 或 write() 方法，同样传入一个 CompletionHandler。这些操作也是立即返回的。
5. 当读或写操作在后台完成后，操作系统会再次调用对应的 completed 方法，让你处理结果。
6. 如果操作失败，则会调用 failed 方法。

示例

// 1. 创建 AsynchronousServerSocketChannel
AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(8080));

// 2. 开始接受连接，并传入回调
serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
    @Override
    public void completed(AsynchronousSocketChannel clientChannel, Void attachment) {
        // 如果想继续接受下一个连接，必须再次调用 accept
        serverChannel.accept(null, this); 
        
        // 3. 处理当前连接的读取
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        clientChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer buffer) {
                buffer.flip();
                // ... 处理数据 ...
                System.out.println(new String(buffer.array(), 0, result));
            }

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

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

// 主线程可以做其他事情，或者只是保持存活
Thread.sleep(Long.MAX_VALUE);

优缺点

适用场景

对延迟和吞吐量要求极高的场景，特别是当 I/O 操作非常耗时（如大文件读写）时，AIO 的优势能充分发挥。然而，由于其复杂性和平台依赖性，在实际应用中，基于 NIO 的框架（如 Netty）通过优化和封装，在大多数场景下已经能满足需求，因此 AIO 的普及度不如 NIO。

总结与对比

总结：

• BIO 是“服务员”模式，一个服务员（线程）只服务一个客人（连接），客人点菜（I/O）时服务员就干等着。
• NIO 是“大堂经理”模式，一个经理（Selector 线程）巡视所有客人（Channel），哪个客人准备好了（就绪），经理就派个服务员（线程）去服务。
• AIO 是“外卖”模式，客人下单（发起 I/O）后就可以去干别的，餐厅（操作系统）做好饭（完成 I/O）后直接送到家（通知应用或回调）。