在 Java 的 I/O 编程领域，BIO、NIO 和 AIO 是三种重要的 I/O 模型，它们各自有着独特的特点和适用场景。理解这三种模型的区别，对于编写高效、高性能的 Java 网络应用程序至关重要。
一、区别对比
| 项 | BIO (Block IO) | NIO (New IO) | AIO(Asynchronous I/O) |
| JDK 版本 | 所有版本 | JDK1.4 及之后 | JDK1.7 及之后 |
| 异步 / 阻塞 | 同步阻塞。一个连接一个线程。线程发起 IO 请求，不管内核是否准备好 IO 操作，从发起请求起，线程一直阻塞，直到操作完成。数据的读取写入必须阻塞在一个线程内等待其完成。 | 同步阻塞 / 非阻塞。一个请求一个线程。客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有 I/O 请求时才启动一个线程进行处理。用户进程也需要时不时的询问 IO 操作是否就绪，这要求用户进程不停的去询问。 | 异步非阻塞。 一个有效请求一个线程。用户进程只需要发起一个 IO 操作然后立即返回，等 IO 操作真正的完成以后，应用程序会得到 IO 操作完成的通知，此时用户进程只需要对数据进行处理就好了，不需要进行实际的 IO 读写操作，因为真正的 IO 读取或者写入操作已经由内核完成了。 |
| 使用场景 | 适用于传统的、并发连接数较少且对性能要求不高的场景 | 已成为解决高并发与大量连接、I/O 处理问题的有效方式。比如：Netty、多人聊天室。 | 适用于连接数目多且连接比较长（重操作）的架构。例如：相册服务器。目前 AIO 的应用还不是很广泛。 |
二、为什么 Netty 用 NIO？
Netty 之前也尝试使用过 AIO，不过又放弃了，因为 AIO 在性能、内存占用上，实际不如 NIO。Netty 作者的原话如下：
- Not faster than NIO (epoll) on unix systems (which is true) 。（在 UNIX 系统上不比 NIO 快）
- There is no daragream support （不支持数据报）
- Unnecessary threading model (too much abstraction without usage) （不必要的线程模型）
详细分析：
- Linux 上，AIO 底层实现仍使用 Epoll，没有很好的实现 AIO，因此性能上没有明显优势，而且被 JDK 封装了一层不容易优化。
- Netty 整体架构是基本 reactor 模型，而 AIO 是 proactor 模型，混合在一起会比较混乱。
- AIO 有个缺点：接收数据需要预先分配缓冲区，而不是 NIO 那种需要接收时才需要分配缓存，所以对连接数量非常大但流量小的情况，会浪费内存。
- Linux 上 AIO 不够成熟，处理回调的结果速度跟不上处理需求，供不应求，造成处理速度有瓶颈。比如：外卖员太少，顾客太多。
另外：NIO 是一种基于通道和缓冲区的 I/O 方式，它可以使用 Native 函数库直接分配堆外内存（区别于 JVM 的运行时数据区），然后通过一个存储在 java 堆里面的 DirectByteBuffer 对象作为这块内存的直接引用进行操作。这样能在一些场景显著提高性能，因为避免了在 Java 堆和 Native 堆中来回复制数据
三、BIO（Blocking I/O） - 阻塞式 I/O
1. 概念
BIO 是 Java 早期的 I/O 模型。在 BIO 中，当一个线程调用read()或write()方法时，该线程会被阻塞，直到数据被完全读取或写入。这意味着在 I/O 操作进行期间，线程无法执行其他任务，严重影响了程序的并发处理能力。
2. 使用场景
BIO 适用于连接数目比较小且固定的架构，这种场景下编程简单，代码容易理解。例如一些传统的企业级应用，其并发连接数相对较少，对性能要求不是特别高。
3. 实例代码
下面是一个简单的 BIO 服务器端示例：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class BIOServer {
public static void main(String[] args) {
try (ServerSocket serverSocket = new ServerSocket(8080)) {
System.out.println("Server started on port 8080");
while (true) {
try (Socket clientSocket = serverSocket.accept()) {
System.out.println("Client connected: " + clientSocket);
BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
String inputLine;
while ((inputLine = in.readLine()) != null) {
System.out.println("Received from client: " + inputLine);
out.println("Server response: " + inputLine);
}
} catch (IOException e) {
e.printStackTrace();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}在这个示例中，serverSocket.accept()方法会阻塞，直到有客户端连接。in.readLine()和out.println()也会阻塞线程，直到数据读取或写入完成。
四、NIO（New I/O） - 非阻塞式 I/O
1. 概念
NIO 是 Java 1.4 引入的新的 I/O 模型。它提供了基于通道（Channel）和缓冲区（Buffer）的 I/O 操作方式。NIO 的主要特点是非阻塞，线程可以在 I/O 操作未完成时继续执行其他任务。通过 Selector（选择器），一个线程可以管理多个通道，大大提高了并发处理能力。
2. 使用场景
NIO 适用于连接数目多且连接比较短（轻操作）的架构，例如聊天服务器、Web 服务器等需要处理大量并发请求的场景。
3. 实例代码
下面是一个简单的 NIO 服务器端示例：
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
public class NIOServer {
private static final int PORT = 8080;
private Selector selector;
public NIOServer() throws IOException {
selector = Selector.open();
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
serverSocketChannel.socket().bind(new InetSocketAddress(PORT));
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("Server started on port " + PORT);
}
public void listen() {
try {
while (true) {
selector.select();
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
while (keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
if (key.isAcceptable()) {
ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
SocketChannel clientSocketChannel = serverSocketChannel.accept();
clientSocketChannel.configureBlocking(false);
clientSocketChannel.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {
SocketChannel clientSocketChannel = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = clientSocketChannel.read(buffer);
if (bytesRead > 0) {
buffer.flip();
byte[] data = new byte[buffer.remaining()];
buffer.get(data);
String message = new String(data);
System.out.println("Received from client: " + message);
ByteBuffer responseBuffer = ByteBuffer.wrap(("Server response: " + message).getBytes());
clientSocketChannel.write(responseBuffer);
}
}
keyIterator.remove();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
NIOServer server = new NIOServer();
server.listen();
} catch (IOException e) {
e.printStackTrace();
}
}
}在这个示例中，ServerSocketChannel和SocketChannel都设置为非阻塞模式。通过Selector监听不同的事件（如OP_ACCEPT和OP_READ），线程可以在多个通道之间切换，而不是阻塞在单个 I/O 操作上。
五、AIO（Asynchronous I/O） - 异步式 I/O
1. 概念
AIO 是 Java 7 引入的异步 I/O 模型，也被称为 NIO.2。与 NIO 相比，AIO 更加注重异步操作。在 AIO 中，I/O 操作是异步完成的，当一个 I/O 操作发起后，线程无需等待操作完成，可以继续执行其他任务。操作完成后，系统会通过回调函数通知线程。
2. 使用场景
AIO 适用于连接数目多且连接比较长（重操作）的架构，例如文件服务器、大数据处理等对 I/O 性能要求极高的场景。
3. 实例代码
下面是一个简单的 AIO 服务器端示例：
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.ExecutionException;
public class AIOServer {
private static final int PORT = 8080;
private AsynchronousServerSocketChannel serverSocketChannel;
public AIOServer() throws IOException {
serverSocketChannel = AsynchronousServerSocketChannel.open();
serverSocketChannel.bind(new InetSocketAddress(PORT));
System.out.println("Server started on port " + PORT);
}
public void listen() {
serverSocketChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
@Override
public void completed(AsynchronousSocketChannel clientSocketChannel, Void attachment) {
try {
serverSocketChannel.accept(null, this);
ByteBuffer buffer = ByteBuffer.allocate(1024);
clientSocketChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
@Override
public void completed(Integer result, ByteBuffer buffer) {
if (result > 0) {
buffer.flip();
byte[] data = new byte[buffer.remaining()];
buffer.get(data);
String message = new String(data);
System.out.println("Received from client: " + message);
ByteBuffer responseBuffer = ByteBuffer.wrap(("Server response: " + message).getBytes());
clientSocketChannel.write(responseBuffer, responseBuffer, new CompletionHandler<Integer, ByteBuffer>() {
@Override
public void completed(Integer result, ByteBuffer buffer) {
try {
clientSocketChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
try {
clientSocketChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
});
}
}
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
try {
clientSocketChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
});
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void failed(Throwable exc, Void attachment) {
exc.printStackTrace();
}
});
try {
System.in.read();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
AIOServer server = new AIOServer();
server.listen();
} catch (IOException e) {
e.printStackTrace();
}
}
}在这个示例中，AsynchronousServerSocketChannel和AsynchronousSocketChannel都是异步的。通过CompletionHandler处理 I/O 操作的完成事件，线程在发起 I/O 操作后可以立即返回，继续执行其他任务。
六、BIO、NIO 和 AIO 的区别总结
- 阻塞方式：
-
- BIO 是阻塞式 I/O，线程在 I/O 操作时会被阻塞。
-
- NIO 是非阻塞式 I/O，线程在 I/O 操作未完成时可以继续执行其他任务。
-
- AIO 是异步式 I/O，I/O 操作完全异步，操作完成后通过回调通知线程。
- 编程模型：
-
- BIO 基于流（Stream）进行操作，代码简单直观。
-
- NIO 基于通道（Channel）和缓冲区（Buffer），通过 Selector 管理多个通道，编程相对复杂。
-
- AIO 同样基于通道和缓冲区，使用异步回调机制，编程模型更加复杂。
- 适用场景：
-
- BIO 适用于并发连接数少且对性能要求不高的场景。
-
- NIO 适用于高并发、轻量级 I/O 操作的场景。
-
- AIO 适用于高并发、重量级 I/O 操作的场景。
通过对 BIO、NIO 和 AIO 的学习和对比，开发者可以根据具体的应用场景选择最合适的 I/O 模型，从而编写出高效、高性能的 Java 应用程序
