前言
在面试和日常开发中，BIO、NIO、AIO 是绕不开的话题。它们是 Java 在不同阶段对 I/O 模型的不同实现，背后折射的是操作系统网络编程模型的演进。本文将梳理这三者的核心概念、工作原理、代码实现以及实际应用场景。
基础概念：阻塞、非阻塞、同步、异步
在深入 Java IO 之前，必须理清两组易混淆的概念：
- 阻塞 vs 非阻塞：描述的是调用方在等待结果时的行为。阻塞意味着调用方会被挂起直到结果就绪；非阻塞意味着调用方立即返回，可以去做别的事情。
- 同步 vs 异步：描述的是数据从内核空间拷贝到用户空间的参与方式。同步意味着用户线程亲自参与数据拷贝；异步意味着操作系统完成所有事情后通知用户线程。
常见的五种 I/O 模型（Unix 网络编程）：
| 模型 |
描述 |
| 阻塞 I/O |
系统调用直到数据到达且拷贝完成才返回 |
| 非阻塞 I/O |
轮询检查数据是否就绪，就绪后同步拷贝 |
| I/O 多路复用 |
单个线程同时监控多个连接，就绪后同步拷贝 |
| 信号驱动 I/O |
数据就绪时内核发送 SIGIO 信号通知 |
| 异步 I/O |
内核完成所有操作后通知，全程非阻塞 |
BIO：一连接一线程的朴素年代
BIO（Blocking I/O）是 Java 最早的 I/O 模型，基于 java.io 包中的 InputStream/OutputStream 和 java.net 中的 ServerSocket/Socket。
BIO 服务端示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| public class BioServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8080);
System.out.println("BIO 服务端启动，监听端口 8080");
while (true) {
Socket client = serverSocket.accept();
new Thread(() -> {
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(client.getInputStream()));
PrintWriter writer = new PrintWriter(
client.getOutputStream(), true)) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println("收到: " + line);
writer.println("Echo: " + line);
}
} catch (IOException e) {
e.printStackTrace();
}
}).start();
}
}
}
|
BIO 的致命缺陷：C10K 问题
BIO 模型下，每个连接需要一个独立的线程来处理。当并发连接数达到数千甚至数万时：
- 线程数量爆炸：每个线程默认占用约 1MB 栈空间，10000 个线程就是 10GB 内存。
- 上下文切换开销：大量线程频繁切换，CPU 大量时间消耗在内核态/用户态的切换上。
- 资源利用率低：大多数连接处于空闲状态，但线程依然被占用。
这就是经典的 C10K 问题（并发处理 10000 个客户端连接）。BIO 在 C10K 面前捉襟见肘，催生了 NIO 的诞生。
伪异步 I/O
使用线程池可以缓解一部分问题，但并未从根本上解决问题：
1
2
3
4
5
6
| ExecutorService pool = Executors.newFixedThreadPool(100);
while (true) {
Socket client = serverSocket.accept();
pool.execute(new ClientHandler(client));
}
|
这种方案本质上还是 BIO：每个 Handler 中的 read() 仍然会阻塞，线程池只是限制了线程数量的上限。当所有线程都阻塞在读操作上时，新的连接就无法被及时处理。
NIO：多路复用的革命
Java NIO（New I/O / Non-blocking I/O）引入于 JDK 1.4，核心是三大组件：Buffer、Channel、Selector。
三大核心组件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.put("Hello NIO".getBytes());
buffer.flip();
byte[] data = new byte[buffer.remaining()];
buffer.get(data);
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false);
serverChannel.bind(new InetSocketAddress(8080));
Selector selector = Selector.open();
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
|
Buffer 和 Channel 的关系类似数据容器和传输管道：Channel 负责传输，Buffer 负责存储。
Selector 多路复用原理
Selector 是 NIO 得以实现单线程处理大量连接的关键。它在底层依赖操作系统的 I/O 多路复用机制：
- Linux 2.6 之前：
select / poll
- Linux 2.6+：
epoll
- macOS / FreeBSD：
kqueue
- Windows：
IOCP（但 Java NIO 在 Windows 上使用的是 select）
epoll 与 select/poll 的关键区别在于：select/poll 每次调用都需要将整个文件描述符集合从用户态拷贝到内核态，并在内核中遍历整个集合；而 epoll 基于事件驱动，使用红黑树维护文件描述符，通过回调机制在有事件发生时直接将就绪的描述符加入就绪链表，避免了遍历全部描述符的开销。
NIO 服务端完整示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
| public class NioServer {
public static void main(String[] args) throws IOException {
Selector selector = Selector.open();
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false);
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("NIO 服务端启动，监听端口 8080");
while (true) {
selector.select();
Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> iterator = keys.iterator();
while (iterator.hasNext()) {
SelectionKey key = iterator.next();
iterator.remove();
if (key.isAcceptable()) {
SocketChannel client = serverChannel.accept();
client.configureBlocking(false);
client.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {
SocketChannel client = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = client.read(buffer);
if (bytesRead == -1) {
client.close();
} else {
buffer.flip();
byte[] data = new byte[buffer.remaining()];
buffer.get(data);
System.out.println("收到: " + new String(data));
client.write(ByteBuffer.wrap(("Echo: " + new String(data)).getBytes()));
}
}
}
}
}
}
|
Reactor 模式的三层进化
NIO 的编程模型虽然强大，但直接使用较为复杂，于是出现了 Reactor 模式（反应器模式）的几种变体：
单线程 Reactor：一个线程负责接收连接和读写处理。适用于并发量不大的场景。
多线程 Reactor：主线程负责接收连接，分发到工作线程池处理读写。大多数 Netty 应用采用的正是这种模型。
主从多线程 Reactor：主 Reactor 负责接收连接，多个子 Reactor 各自负责一组连接的读写。适用于超高并发场景。
Netty：NIO 编程的最佳实践
直接基于 Java NIO 编写高性能网络应用非常复杂（ByteBuffer 的 flip 操作、粘包/拆包处理、空轮询 bug 等）。Netty 通过优雅的 API 抽象解决了这些问题。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| public class NettyServer {
public static void main(String[] args) throws InterruptedException {
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) {
ch.pipeline()
.addLast(new StringDecoder())
.addLast(new StringEncoder())
.addLast(new SimpleChannelInboundHandler<String>() {
@Override
protected void channelRead0(ChannelHandlerContext ctx, String msg) {
System.out.println("收到: " + msg);
ctx.writeAndFlush("Echo: " + msg);
}
});
}
});
ChannelFuture future = bootstrap.bind(8080).sync();
System.out.println("Netty 服务端启动");
future.channel().closeFuture().sync();
}
}
|
Netty 的核心概念：
- ChannelPipeline：处理器链，数据在其中按顺序经过各个 Handler。
- EventLoop：事件循环，每个 EventLoop 绑定一组 Channel，处理这些 Channel 的所有 I/O 事件。
- ByteBuf：Netty 自研的字节容器，比 JDK 的 ByteBuffer 更灵活高效，支持池化和零拷贝。
AIO：异步非阻塞的进一步
Java AIO（Asynchronous I/O）在 JDK 7 中引入，实现了真正的异步 I/O。它在底层依赖操作系统级别的异步 I/O 支持（Windows 的 IOCP，Linux 的 epoll 模拟——Linux 原生 AIO 对网络支持不完善）。
AIO 的两种编程风格
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
public class AioServer {
public static void main(String[] args) throws IOException {
AsynchronousServerSocketChannel server =
AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(8080));
server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
@Override
public void completed(AsynchronousSocketChannel client, Void attachment) {
server.accept(null, this);
ByteBuffer buffer = ByteBuffer.allocate(1024);
client.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
@Override
public void completed(Integer bytesRead, ByteBuffer buf) {
buf.flip();
byte[] data = new byte[buf.remaining()];
buf.get(data);
System.out.println("收到: " + new String(data));
}
@Override
public void failed(Throwable exc, ByteBuffer buf) {
exc.printStackTrace();
}
});
}
@Override
public void failed(Throwable exc, Void attachment) {
exc.printStackTrace();
}
});
Thread.currentThread().join();
}
}
Future<Integer> future = client.read(buffer);
Integer bytesRead = future.get();
|
AIO 的尴尬处境
AIO 的设计理念很先进——完全异步，无需用户线程参与数据拷贝。但在 Java 生态中，AIO 的实际应用远不如 NIO 广泛。原因包括：
- Linux 支持不完善：Linux 内核的 AIO 主要针对磁盘 I/O，对网络 I/O 的支持长期不理想。JDK 在 Linux 上使用
epoll 来模拟 AIO，实际上底层仍然是同步的。
- Netty 选择 NIO：作为 Java 高性能网络编程的事实标准，Netty 坚持在 NIO 上深耕，未将 AIO 作为主推方向。
- 编程复杂度：回调地狱问题（Callback Hell）让代码难以维护。
三种 IO 模型的对比
| 维度 |
BIO |
NIO |
AIO |
| I/O 模型 |
同步阻塞 |
同步非阻塞（多路复用） |
异步非阻塞 |
| 连接与线程关系 |
1:1 |
M:1（Selector） |
M:0（内核回调） |
| 编程复杂度 |
简单 |
中等 |
较高 |
| 并发支持 |
低（数百） |
高（数万~数十万） |
理论上更高 |
| 吞吐量 |
低 |
高 |
理论上更高 |
| JDK 引入版本 |
1.0 |
1.4 |
1.7 |
| 主流框架 |
传统 Web 服务器 |
Netty, Mina |
较少使用 |
如何选择 I/O 模型
在选择 I/O 模型时，可以参考以下建议：
- 连接数少、逻辑简单：BIO 即可胜任。简单直接的代码，编起来快，调起来容易。
- 高并发、长连接：优先选择 Netty（基于 NIO）。这是目前 Java 高性能网络编程的工业级标准方案。
- 超高并发、追求极致性能：考虑 NIO + Reactor 主从模型，配合 Netty 的零拷贝等优化。
- AIO 暂不推荐作为主力：除非你明确知道自己在 Windows 环境下的 IOCP 有绝对优势，且能承受回调式编程的维护成本。
总结
从 BIO 到 NIO 再到 AIO，Java I/O 模型的演进反映了互联网应用从少量连接到海量并发的发展需求。BIO 简单直观但无法应对高并发，NIO 通过 Selector 多路复用实现了单线程管理数千连接的能力，AIO 虽然理念先进但受限于操作系统支持和生态成熟度。对于绝大多数 Java 开发者来说，理解 NIO 的原理并掌握 Netty 的使用，是通向高性能网络编程的最短路径。