2026年4月：作为AI助手带你彻底搞懂Java IO模型（BIONIOAIO）从原理到面试

// BIO服务端示例
public class BioServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("BIO服务端启动，等待连接...");
        while (true) {
            // 阻塞：等待客户端连接
            Socket socket = serverSocket.accept();
            System.out.println("新客户端连接：" + socket);
            // 为每个连接创建独立线程
            new Thread(() -> {
                try (InputStream is = socket.getInputStream();
                     OutputStream os = socket.getOutputStream()) {
                    byte[] buffer = new byte[1024];
                    // 阻塞：读取客户端数据
                    int len = is.read(buffer);
                    String msg = new String(buffer, 0, len);
                    System.out.println("接收客户端数据：" + msg);
                    os.write(("BIO响应：" + msg).getBytes());
                    os.flush();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

// NIO服务端核心代码
public class NioServer {
    public static void main(String[] args) throws IOException {
        // 1. 打开Selector
        Selector selector = Selector.open();
        // 2. 打开ServerSocketChannel并设置为非阻塞
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.bind(new InetSocketAddress(8080));
        // 3. 注册ACCEPT事件
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        
        while (true) {
            // 阻塞等待事件就绪（可传入超时参数避免无限等待）
            selector.select();
            Set<SelectionKey> keys = selector.selectedKeys();
            Iterator<SelectionKey> iter = keys.iterator();
            while (iter.hasNext()) {
                SelectionKey key = iter.next();
                iter.remove(); // 必须手动移除
                
                if (key.isAcceptable()) {
                    // 处理新连接
                    SocketChannel socketChannel = serverChannel.accept();
                    socketChannel.configureBlocking(false);
                    socketChannel.register(selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) {
                    // 处理读事件
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int len = socketChannel.read(buffer);
                    if (len > 0) {
                        buffer.flip();  // 切换为读模式
                        System.out.println("收到数据：" + new String(buffer.array(), 0, len));
                    }
                }
            }
        }
    }
}

// AIO服务端简化示例
public class AioServer {
    public static void main(String[] args) throws IOException {
        AsynchronousServerSocketChannel serverChannel = 
            AsynchronousServerSocketChannel.open();
        serverChannel.bind(new InetSocketAddress(8080));
        
        serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
            @Override
            public void completed(AsynchronousSocketChannel clientChannel, Void attachment) {
                // 继续接受下一个连接
                serverChannel.accept(null, this);
                
                // 异步读取数据
                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.currentThread().join();
    }
}

JDK 1.0 (1996)   → BIO (java.io) 
JDK 1.4 (2002)   → NIO (java.nio) + 多路复用
JDK 1.7 (2011)   → AIO (NIO.2) + 异步回调
Java 21+ (2023+) → 虚拟线程 + BIO代码风格