BIO、NIO、AIO 是 Java 中三种核心的 IO 模型，本质是操作系统层面 IO 操作的不同处理方式，核心差异体现在「阻塞/非阻塞」「同步/异步」两个维度，适用于不同并发规模和业务场景。以下从核心定义、原理、代码示例、优缺点、使用场景 全方位拆解，结合 Java 实战场景说明选型逻辑。

一、前置概念：先理清「同步/异步」「阻塞/非阻塞」

这是理解 IO 模型的基础，避免字面误解：

维度	定义
同步（Sync）	应用程序主动等待 IO 操作完成（数据就绪、读写完成），期间线程需参与 IO 过程
异步（Async）	应用程序发起 IO 请求后直接返回，由操作系统完成 IO 操作，完成后通过回调/通知告知应用
阻塞（Block）	IO 操作未完成时，线程被挂起（暂停执行），直到 IO 完成或异常
非阻塞（Non-block）	IO 操作未完成时，线程不挂起，立即返回「未完成」状态，可继续执行其他任务

二、BIO/NIO/AIO 核心区别对比表

特性	BIO (Blocking IO) 阻塞IO	NIO (Non-blocking IO/New IO) 非阻塞IO	AIO (Asynchronous IO) 异步IO（NIO2）
核心模型	同步阻塞	同步非阻塞（Reactor 反应器模式）	异步非阻塞（Proactor 前摄器模式）
连接处理	一个连接对应一个线程	一个线程处理多个连接（多路复用）	操作系统处理连接/IO，回调通知应用
核心组件	ServerSocket、Socket	Selector、Channel、Buffer	AsynchronousSocketChannel、CompletionHandler
读写特点	读写阻塞，直到数据就绪/传输完成	读写非阻塞，轮询就绪的 Channel	发起读写后直接返回，操作系统完成后回调
并发能力	低（线程数=连接数，线程开销大）	高（少量线程处理大量连接）	极高（完全由系统调度，无轮询开销）
编程复杂度	简单（线性逻辑）	中等（Reactor 模式需处理事件轮询）	高（回调/异步编程，需处理异常回调）
系统依赖	无（纯 Java 实现）	依赖操作系统多路复用（epoll/kqueue）	依赖操作系统异步 IO 支持（Linux 差，Windows IOCP 好）
典型应用	低并发场景（如简单 Socket 服务）	高并发短连接（如 Netty、Tomcat8+）	高并发长连接/耗时 IO（如文件下载）

三、逐个解析（原理+代码+优缺点）

1. BIO（阻塞 IO）

核心原理

• 服务端启动 ServerSocket 监听端口，调用 accept() 阻塞等待客户端连接；
• 每建立一个客户端连接，创建一个新线程处理该连接的读写操作；
• 读写操作（InputStream.read()/OutputStream.write()）阻塞，直到数据传输完成或异常。

代码示例（简单 BIO 服务器）

public class BioServer {
    public static void main(String[] args) throws IOException {
        // 1. 绑定端口
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("BIO 服务器启动，监听 8080 端口...");

        while (true) {
            // 2. 阻塞等待客户端连接
            Socket socket = serverSocket.accept(); 
            System.out.println("客户端连接：" + socket.getInetAddress());

            // 3. 新建线程处理连接
            new Thread(() -> {
                try (InputStream is = socket.getInputStream();
                     OutputStream os = socket.getOutputStream()) {
                    byte[] buf = new byte[1024];
                    // 4. 阻塞读取客户端数据
                    int len = is.read(buf); 
                    if (len > 0) {
                        String msg = new String(buf, 0, len);
                        System.out.println("收到客户端消息：" + msg);
                        // 5. 阻塞写回响应
                        os.write(("BIO 响应：" + msg).getBytes());
                        os.flush();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

优点

• 编程逻辑简单，线性思维即可实现，易调试、易维护；
• 无额外依赖，兼容所有 Java 版本，适合入门和简单场景。

缺点

• 高并发下线程耗尽：每连接一个线程，若并发数达 1000，需创建 1000 个线程，线程切换/内存开销（每个线程栈默认 1MB）会压垮服务器；
• 阻塞浪费资源：线程在等待数据（如客户端未发送数据）时完全阻塞，无法处理其他任务。

优化方案

• 线程池复用线程（如 Executors.newFixedThreadPool），限制最大线程数，避免线程爆炸；
• 但本质仍是「一个线程处理一个连接」，仅缓解问题，无法解决阻塞核心痛点。

2. NIO（非阻塞 IO/New IO）

核心原理

NIO 是对 BIO 的核心改进，基于「多路复用器（Selector）」实现「一个线程处理多个连接」：

1. Channel（通道）：双向读写（BIO 的 Stream 是单向），支持非阻塞操作；
2. Buffer（缓冲区）：数据读写必须通过 Buffer（BIO 直接读写流），减少数据拷贝；
3. Selector（多路复用器）：核心组件，监听多个 Channel 的事件（连接就绪、读就绪、写就绪），线程通过 select() 轮询就绪事件，仅处理有事件的 Channel。

代码示例（简单 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.socket().bind(new InetSocketAddress(8080));
        // 3. 设置为非阻塞模式
        serverChannel.configureBlocking(false);
        // 4. 注册连接就绪事件到 Selector
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("NIO 服务器启动，监听 8080 端口...");

        while (true) {
            // 5. 阻塞等待就绪事件（可设置超时时间）
            selector.select(); 
            // 6. 获取所有就绪事件
            Set<SelectionKey> keys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = keys.iterator();

            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove(); // 必须移除，避免重复处理

                // 7. 处理连接就绪事件
                if (key.isAcceptable()) {
                    ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
                    SocketChannel socketChannel = ssc.accept(); // 非阻塞，立即返回
                    socketChannel.configureBlocking(false);
                    // 注册读就绪事件
                    socketChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println("客户端连接：" + socketChannel.getRemoteAddress());
                }

                // 8. 处理读就绪事件
                if (key.isReadable()) {
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer buf = ByteBuffer.allocate(1024);
                    // 非阻塞读取，返回读取的字节数（0 表示未就绪，-1 表示连接关闭）
                    int len = socketChannel.read(buf); 
                    if (len > 0) {
                        buf.flip(); // 切换为读模式
                        String msg = new String(buf.array(), 0, len);
                        System.out.println("收到客户端消息：" + msg);
                        // 写回响应
                        socketChannel.write(ByteBuffer.wrap(("NIO 响应：" + msg).getBytes()));
                    } else if (len < 0) {
                        key.cancel(); // 连接关闭，取消注册
                        socketChannel.close();
                    }
                }
            }
        }
    }
}

优点

• 高并发支持：少量线程（如 10 个）即可处理上万连接，线程开销极低；
• 非阻塞读写：线程无需等待数据，可处理其他连接，资源利用率高；
• 零拷贝优化：Channel/Buffer 减少数据在用户态和内核态的拷贝（如 FileChannel.transferTo）。

缺点

• 编程复杂度高：需理解 Reactor 模式、事件轮询、Buffer 切换（flip/rewind）等概念；
• 轮询开销：selector.select() 虽阻塞，但高并发下轮询就绪事件仍有一定开销；
• 句柄限制：Linux 下 Selector 基于 epoll，但默认文件句柄数有限（需系统调优）。

工业级封装

实际开发中不会手写 NIO 底层代码，而是使用 Netty（基于 NIO 封装，解决了 NIO 的坑，如空轮询、断线重连等），Netty 是高性能网络框架的事实标准（如 Dubbo、RocketMQ、Elasticsearch 均基于 Netty）。

3. AIO（异步 IO/NIO2）

核心原理

AIO 是「真正的异步 IO」：

1. 应用程序发起 IO 请求（连接/读写）后，直接返回，不阻塞、不轮询；
2. 操作系统接管 IO 操作，完成后通过 CompletionHandler 回调通知应用程序；
3. 完全基于 Proactor 模式，线程仅在 IO 完成后处理结果，无任何等待/轮询开销。

代码示例（简单 AIO 服务器）

public class AioServer {
    public static void main(String[] args) throws IOException {
        // 1. 创建异步服务器通道
        AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open();
        serverChannel.bind(new InetSocketAddress(8080));
        System.out.println("AIO 服务器启动，监听 8080 端口...");

        // 2. 异步接受连接（第一个参数：附件，第二个参数：回调处理器）
        serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
            @Override
            public void completed(AsynchronousSocketChannel socketChannel, Object attachment) {
                // 3. 继续接受下一个连接（否则只能处理一个连接）
                serverChannel.accept(null, this);
                System.out.println("客户端连接：" + socketChannel.getRemoteAddress());

                // 4. 异步读取数据
                ByteBuffer buf = ByteBuffer.allocate(1024);
                socketChannel.read(buf, buf, new CompletionHandler<Integer, ByteBuffer>() {
                    @Override
                    public void completed(Integer len, ByteBuffer buffer) {
                        if (len > 0) {
                            buffer.flip();
                            String msg = new String(buffer.array(), 0, len);
                            System.out.println("收到客户端消息：" + msg);
                            // 5. 异步写回响应
                            socketChannel.write(ByteBuffer.wrap(("AIO 响应：" + msg).getBytes()));
                        }
                    }

                    @Override
                    public void failed(Throwable exc, ByteBuffer buffer) {
                        exc.printStackTrace();
                        try {
                            socketChannel.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }

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

        // 防止主线程退出
        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

优点

• 极致性能：无轮询/阻塞开销，操作系统级异步，适合超高并发、长耗时 IO；
• 资源利用率最高：线程仅在 IO 完成后工作，无空闲等待。

缺点

• 系统依赖强：Linux 内核对 AIO 支持不完善（仅对文件 IO 友好，网络 IO 仍基于 epoll 模拟），Windows 下 IOCP 支持好；
• 编程复杂度极高：异步回调嵌套（回调地狱），异常处理复杂，调试难度大；
• 生态不成熟：Java 中 AIO 应用极少，Netty 也未采用 AIO（因 Linux 支持差）。

四、使用场景与选型建议

场景类型	推荐 IO 模型	核心原因
低并发、简单场景	BIO	编程简单，无需复杂逻辑，如内部小工具、测试服务、连接数 < 100 的场景
高并发短连接（主流）	NIO（Netty）	性能高、生态成熟，如微服务通信（Dubbo）、MQ（RocketMQ）、Web 服务器（Tomcat8+）、Redis 客户端
高并发长连接/耗时 IO	AIO（谨慎）	如大文件下载、视频流传输、数据库异步读写，但 Java 中优先选 Netty 的 NIO 异步封装
跨平台高并发	NIO（Netty）	AIO 跨平台支持差，Netty 已优化 NIO 性能，足够应对绝大多数高并发场景

五、关键补充

1. NIO 是 Java 高并发网络编程的主流：AIO 虽理论性能更好，但因 Linux 支持问题，实际项目中几乎都用 Netty 封装的 NIO；
2. BIO 并非完全无用：在连接数少、逻辑简单的场景下，BIO 的开发效率远高于 NIO/AIO；
3. 同步/异步是核心差异：BIO/NIO 都是同步（线程需参与 IO 过程），AIO 是异步（操作系统接管）；
4. Netty 屏蔽了 IO 模型差异：Netty 提供统一 API，可适配 BIO/NIO，且解决了 NIO 的底层坑（如 Selector 空轮询、断线重连），是工业级首选。

总结

选型维度	BIO	NIO	AIO
开发效率	最高	中等	最低
运行性能	最低	高	理论最高（实际受限）
生产成熟度	高（简单场景）	极高（主流）	低（极少使用）

实际项目中，优先选择 Netty（NIO 封装） 应对高并发，简单场景用 BIO，AIO 仅在 Windows 平台/耗时文件 IO 场景考虑。