Java NIO 和 IO 有什么区别
java nio（new input/output）与传统的 java io 主要区别在于数据处理的模式、阻塞行为以及核心组件的设计。传统 io 是面向流的（stream-oriented）、阻塞式的，每次读写操作都会导致线程挂起等待；而 nio 是面向缓冲区的（buffer-oriented）、非阻塞式的，支持通过 selector 实现单线程管理多个通道（channel），从而显著提高高并发场景下的资源利用率。
IO 的流式处理与阻塞机制如何工作
在传统的 Java IO 中，数据以流的形式单向传输，且所有 I/O 操作都是阻塞的。这意味着当线程执行读取或写入操作时，如果数据尚未准备好或缓冲区已满，线程将被挂起，直到操作完成才能继续执行后续代码。这种模型简单直观，但在处理大量并发连接时，每个连接都需要一个独立的线程，导致系统资源消耗巨大。
import java.io.*;
public class TraditionalIOExample {
public static void main(String[] args) throws IOException {
// 创建服务器套接字并监听端口
ServerSocket serverSocket = new ServerSocket(8080);
System.out.println("Server started on port 8080");
while (true) {
// accept() 是阻塞调用，直到有客户端连接
Socket clientSocket = serverSocket.accept();
System.out.println("Client connected: " + clientSocket.getRemoteSocketAddress());
// 为每个客户端启动一个新线程
new Thread(() -> handleClient(clientSocket)).start();
}
}
private static void handleClient(Socket socket) {
try (InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream()) {
byte[] buffer = new byte[1024];
// read() 是阻塞调用，直到读取到数据或流结束
int bytesRead = in.read(buffer);
if (bytesRead > 0) {
out.write(buffer, 0, bytesRead);
System.out.println("Data sent to client");
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
上述代码展示了传统 IO 的典型用法。`ServerSocket.accept()` 会阻塞当前线程，直到有新连接到达。一旦连接建立，程序会为每个客户端创建一个新线程来处理请求。在 `handleClient` 方法中，`InputStream.read()` 同样会阻塞，直到有数据可读。这种“一连接一线程”的模式在连接数较少时表现良好，但随着并发量增加，线程上下文切换开销和内存占用会成为瓶颈。
NIO 的非阻塞特性与多路复用机制
NIO 引入了通道（Channel）、缓冲区（Buffer）和选择器（Selector）三大核心组件。通道是双向的，既可以读也可以写，而传统 IO 流通常是单向的。缓冲区是数据的容器，所有 I/O 操作都通过缓冲区进行。最关键的是选择器，它允许单个线程监控多个通道的 I/O 状态，实现了多路复用。当某个通道没有就绪事件（如可读或可写）时，线程不会被阻塞，而是可以去处理其他通道或执行其他任务。
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
public class NIOExample {
public static void main(String[] args) throws IOException {
// 创建非阻塞服务器通道
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false);
serverChannel.bind(new InetSocketAddress(8080));
// 创建选择器
Selector selector = Selector.open();
// 注册通道到选择器，监听 ACCEPT 事件
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("NIO Server started on port 8080");
while (true) {
// select() 是非阻塞的，如果没有就绪事件，它会等待直到有事件发生
// 但不会像 accept() 那样无限期阻塞线程，而是可以设置超时
selector.select();
Iterator<selectionkey> keys = selector.selectedKeys().iterator();
while (keys.hasNext()) {
SelectionKey key = keys.next();
keys.remove();
if (key.isAcceptable()) {
// 接受新连接
SocketChannel clientChannel = serverChannel.accept();
clientChannel.configureBlocking(false);
// 注册新通道，监听 READ 事件
clientChannel.register(selector, SelectionKey.OP_READ);
System.out.println("Client connected: " + clientChannel.getRemoteAddress());
} else if (key.isReadable()) {
// 处理可读事件
SocketChannel clientChannel = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = clientChannel.read(buffer);
if (bytesRead > 0) {
buffer.flip();
clientChannel.write(buffer);
System.out.println("Data received and echoed");
} else if (bytesRead == -1) {
clientChannel.close();
}
}
}
}
}
}</selectionkey>
在这个 NIO 示例中，`ServerSocketChannel` 被设置为非阻塞模式，并通过 `Selector` 注册了 `OP_ACCEPT` 事件。主循环调用 `selector.select()`，该方法会阻塞直到至少有一个通道就绪，但一旦有事件发生，它会立即返回并遍历就绪的键。这种方式使得单个线程可以高效地管理成千上万个并发连接，而无需为每个连接分配一个线程。`SocketChannel` 的 `read()` 和 `write()` 操作也是非阻塞的，如果缓冲区中没有数据或空间不足，它们会立即返回，而不是挂起线程。
基于程序中 Buffer 翻转的具体问题
在 NIO 编程中，`ByteBuffer` 的 `flip()` 方法是理解其工作原理的关键。当从通道读取数据到缓冲区时，缓冲区处于“写入模式”，`position` 指向下一个写入位置，`limit` 等于容量。读取完成后，必须调用 `flip()` 方法将缓冲区切换到“读取模式”。此时，`limit` 被设置为当前的 `position`，而 `position` 被重置为 0。这使得后续的写入操作可以从缓冲区的开头开始，直到 `limit` 为止。如果不进行翻转，直接尝试从缓冲区读取数据，将会得到空结果，因为 `position` 仍然指向末尾，而 `limit` 仍然是容量，导致可读字节数为零。
Java免费学习笔记：立即使用
解锁 Java 大师之旅：从入门到精通的终极指南
