BIO、NIO 和 AIO：深入理解 Java 网络编程模型

2023-10-11 09:13:55

1. BIO：阻塞式 IO

BIO（Blocking I/O）是传统的网络编程模型，也是最容易理解的模型。在 BIO 模型中，当应用程序需要进行网络操作时，它会调用阻塞式 IO API，比如 read() 或 write()。这些 API 会一直阻塞，直到网络操作完成，才会返回。

BIO 模型的优点是简单易用，缺点是效率较低，因为应用程序在等待网络操作完成时无法做其他事情。

2. NIO：非阻塞式 IO

NIO（Non-blocking I/O）是非阻塞式的网络编程模型。在 NIO 模型中，应用程序使用非阻塞式 IO API，比如 read() 或 write()。这些 API 不会阻塞，而是立即返回，即使网络操作还没有完成。

应用程序需要不断地轮询网络事件，以检查网络操作是否已经完成。NIO 模型的优点是效率较高，因为应用程序在等待网络操作完成时可以做其他事情。缺点是编程复杂度较高。

3. AIO：异步 IO

AIO（Asynchronous I/O）是异步式的网络编程模型。在 AIO 模型中，应用程序使用异步式 IO API，比如 aio_read() 或 aio_write()。这些 API 会立即返回，并且应用程序不会阻塞，直到网络操作完成。

应用程序可以注册一个回调函数，当网络操作完成时，操作系统会调用这个回调函数。AIO 模型的优点是效率最高，因为应用程序在等待网络操作完成时可以做其他事情。缺点是编程复杂度最高。

4. 性能比较

下表比较了 BIO、NIO 和 AIO 三种模型的性能。

模型	吞吐量	延迟	复杂度
BIO	低	高	低
NIO	高	低	中
AIO	最高	最低	高

5. 选择合适的模型

在选择网络编程模型时，需要考虑以下因素：

吞吐量： 应用程序需要处理多少数据。
延迟： 应用程序对延迟的容忍度。
复杂度： 应用程序开发人员的技能和经验。

如果应用程序需要处理大量数据，那么 NIO 或 AIO 模型是更好的选择。如果应用程序对延迟很敏感，那么 NIO 或 AIO 模型也是更好的选择。如果应用程序的开发人员经验不足，那么 BIO 模型是更好的选择。

6. 代码示例

以下代码示例演示了如何使用 BIO、NIO 和 AIO 模型来实现一个简单的网络服务器。

BIO 代码示例：

import java.net.*;
import java.io.*;

public class BioServer {

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        while (true) {
            Socket socket = serverSocket.accept();
            InputStream input = socket.getInputStream();
            OutputStream output = socket.getOutputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(input));
            PrintWriter writer = new PrintWriter(output, true);

            String line;
            while ((line = reader.readLine()) != null) {
                writer.println("Echo: " + line);
            }

            socket.close();
        }
    }
}

NIO 代码示例：

import java.net.*;
import java.io.*;
import java.nio.*;
import java.nio.channels.*;

public class NioServer {

    public static void main(String[] args) throws IOException {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(8080));
        serverSocketChannel.configureBlocking(false);

        Selector selector = Selector.open();
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {
            int num = selector.select();
            if (num > 0) {
                Set<SelectionKey> keys = selector.selectedKeys();
                for (SelectionKey key : keys) {
                    if (key.isAcceptable()) {
                        SocketChannel socketChannel = serverSocketChannel.accept();
                        socketChannel.configureBlocking(false);
                        socketChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
                    } else if (key.isReadable()) {
                        SocketChannel socketChannel = (SocketChannel) key.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        int numBytesRead = socketChannel.read(buffer);
                        if (numBytesRead == -1) {
                            socketChannel.close();
                        } else {
                            buffer.flip();
                            String message = new String(buffer.array(), 0, buffer.limit());
                            System.out.println("Received: " + message);

                            ByteBuffer outputBuffer = ByteBuffer.allocate(1024);
                            outputBuffer.put("Echo: " + message);
                            outputBuffer.flip();
                            socketChannel.write(outputBuffer);
                        }
                    } else if (key.isWritable()) {
                        SocketChannel socketChannel = (SocketChannel) key.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        buffer.put("Echo: Hello world!");
                        buffer.flip();
                        socketChannel.write(buffer);

                        socketChannel.close();
                    }
                }
                keys.clear();
            }
        }
    }
}

AIO 代码示例：

import java.net.*;
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.util.concurrent.*;

public class AioServer {

    public static void main(String[] args) throws IOException {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(8080));
        serverSocketChannel.configureBlocking(false);

        CompletionHandler<AsynchronousSocketChannel, Void> acceptHandler = new CompletionHandler<>() {

            @Override
            public void completed(AsynchronousSocketChannel socketChannel, Void attachment) {
                serverSocketChannel.accept(null, this);

                ByteBuffer buffer = ByteBuffer.allocate(1024);
                socketChannel.read(buffer, null, new CompletionHandler<>() {

                    @Override
                    public void completed(Integer numBytesRead, Void attachment) {
                        if (numBytesRead == -1) {
                            socketChannel.close();
                        } else {
                            buffer.flip();
                            String message = new String(buffer.array(), 0, buffer.limit());
                            System.out.println("Received: " + message);

                            ByteBuffer outputBuffer = ByteBuffer.allocate(1024);
                            outputBuffer.put("Echo: " + message);
                            outputBuffer.flip();
                            socketChannel.write(outputBuffer, null, new CompletionHandler<>() {

                                @Override
                                public void completed(Integer numBytesWritten, Void attachment) {
                                    socketChannel.close();
                                }

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

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

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

        serverSocketChannel.accept(null, acceptHandler);

        ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
        executorService.submit(() -> {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}