深入剖析 Java I/O 模型：IO/BIO/NIO/AIO，高并發(fā)性能優(yōu)化全攻略！
從阻塞式BIO到零拷貝NIO，再到異步AIO，一文搞懂Java高并發(fā)I/O的底層原理與實戰(zhàn)優(yōu)化。包含多路復用、內存映射、Selector事件驅動等硬核技術，搭配代碼對比+性能數(shù)據(jù)，帶你徹底告別線程阻塞和資源浪費！無論是面試突擊還是項目優(yōu)化，這份指南都能讓你快人一步。
一、BIO（Blocking I/O）詳解
Java BIO（Blocking I/O，阻塞式 I/O）是 Java 最基礎的 I/O 模型，采用同步阻塞的方式處理數(shù)據(jù)流，適用于簡單、低并發(fā)的場景。
1. BIO 核心特點
1.1 阻塞式模型
- 線程阻塞：每個 I/O 操作（如 read()、write()）都會阻塞當前線程，直到數(shù)據(jù)就緒。
- 一連接一線程：每個客戶端連接需要獨立的線程處理，高并發(fā)時資源消耗大。
1.2 核心類
- **InputStream / OutputStream**：字節(jié)流讀寫。
- **Reader / Writer**：字符流讀寫。
- **ServerSocket / Socket**：TCP 網(wǎng)絡通信。
2. BIO 工作機制
圖片
3. 代碼片段
3.1 BIO 服務器（單線程阻塞）
ServerSocket serverSocket = new ServerSocket(8080);
while (true) {
Socket socket = serverSocket.accept(); // 阻塞等待連接
InputStream in = socket.getInputStream();
byte[] buffer = new byte[1024];
int len = in.read(buffer); // 阻塞讀取數(shù)據(jù)
System.out.println("收到數(shù)據(jù): " + new String(buffer, 0, len));
socket.close();
}3.2 BIO 服務器（線程池優(yōu)化）
ExecutorService threadPool = Executors.newFixedThreadPool(10);
ServerSocket serverSocket = new ServerSocket(8080);
while (true) {
Socket socket = serverSocket.accept();
threadPool.execute(() -> {
try {
InputStream in = socket.getInputStream();
byte[] buffer = newbyte[1024];
int len = in.read(buffer); // 阻塞讀取
System.out.println("處理數(shù)據(jù): " + new String(buffer, 0, len));
} catch (IOException e) {
e.printStackTrace();
}
});
}4. BIO 的優(yōu)缺
4.1 優(yōu)點
? 簡單易用：代碼直觀，適合快速開發(fā)。? 兼容性好：所有 Java 版本和操作系統(tǒng)支持。
4.2 缺點
? 性能瓶頸：線程數(shù)隨連接數(shù)線性增長，高并發(fā)時資源耗盡。? 擴展性差：不適合長連接或高吞吐場景。
5. 使用場景
5.1 適合 BIO 的場景
? 低并發(fā)應用：小型 HTTP 服務、本地文件處理。? 快速原型開發(fā)：驗證邏輯時無需復雜設計。
5.2 不適合 BIO 的場景
? 高并發(fā)服務器（如聊天室、游戲后端）。? 長連接服務（如實時數(shù)據(jù)推送）。
6. 小結
- BIO 是同步阻塞模型，適合簡單、低并發(fā)的場景。
- 缺點明顯：線程資源消耗大，需用線程池優(yōu)化。
- 升級建議：高并發(fā)場景優(yōu)先選擇 NIO（如 Netty）或 AIO。
?? 現(xiàn)代開發(fā)推薦：直接使用 Netty（基于 NIO 的高性能框架），避免手動管理線程和阻塞問題。
二、NIO（New I/O）詳解
Java NIO（New I/O）是 Java 1.4 引入的非阻塞式 I/O 模型，相比傳統(tǒng)的 java.io（阻塞式流式 I/O），它提供了更高效的緩沖區(qū)（Buffer）、通道（Channel）、選擇器（Selector） 機制，適合高并發(fā)網(wǎng)絡編程和大文件處理。
圖片
圖說明
- Selector（選擇器）
- 核心多路復用器，監(jiān)聽多個 Channel 的 就緒事件（OP_READ/OP_WRITE等）。
- 通過 select() 阻塞直到至少一個 Channel 就緒。
- Channel（通道）
雙向數(shù)據(jù)管道（支持讀/寫），需配置為非阻塞模式：
channel.configureBlocking(false);類型：SocketChannel、ServerSocketChannel、DatagramChannel。
Buffer（緩沖區(qū)）
數(shù)據(jù)中轉站，通過 put()/get()讀寫，需手動flip()` 切換模式。
與傳統(tǒng) BIO 對比
NIO 單線程可處理多連接，BIO 需為每個連接創(chuàng)建線程。
1. Java NIO 核心組件
1.1 Buffer（緩沖區(qū)）
- 作用：臨時存儲數(shù)據(jù)（類似數(shù)組，但更高效）。
- 類型：ByteBuffer（最常用）、CharBuffer、IntBuffer 等。
- 關鍵操作：
put() / get()：寫入/讀取數(shù)據(jù)。
flip()：切換讀寫模式（寫 → 讀）。
clear() / compact()：清空或壓縮緩沖區(qū)。
代碼片段：
ByteBuffer buffer = ByteBuffer.allocate(1024); // 分配 1KB 緩沖區(qū)
buffer.put("你好".getBytes(StandardCharsets.UTF_8)); // 寫入數(shù)據(jù)
buffer.flip(); // 切換為讀模式
while (buffer.hasRemaining()) {
System.out.print((char) buffer.get()); // 逐個字節(jié)讀取
}1.2 Channel（通道）
- 作用：連接數(shù)據(jù)源（文件、網(wǎng)絡套接字），支持非阻塞讀寫。
- 常見實現(xiàn)：
FileChannel：文件讀寫。
SocketChannel / ServerSocketChannel：TCP 通信。
DatagramChannel：UDP 通信。
1.2.1 FileChannel
代碼片段（文件復制） ：
try (FileChannel srcChannel = FileChannel.open(Paths.get("source.txt"));
FileChannel destChannel = FileChannel.open(Paths.get("target.txt"),
StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
srcChannel.transferTo(0, srcChannel.size(), destChannel); // 零拷貝高效傳輸
}1.2.2 DatagramChannel：UDP 通信
DatagramChannel 是 Java NIO 提供的非阻塞 UDP 通信實現(xiàn)，相比傳統(tǒng) DatagramSocket，它支持 Selector 多路復用，適合高性能 UDP 應用（如視頻流、游戲同步、DNS 查詢）。
1. 核心特性
- 非阻塞模式：可注冊到 Selector 實現(xiàn)多路復用。
- 直接緩沖區(qū)支持：零拷貝優(yōu)化（ByteBuffer.allocateDirect）。
- 面向數(shù)據(jù)報：無需建立連接，直接發(fā)送/接收數(shù)據(jù)包。
2. 代碼片段
2.1 UDP 服務端（接收數(shù)據(jù)）
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
publicclass UDPServer {
public static void main(String[] args) throws IOException {
// 1. 創(chuàng)建 DatagramChannel 并綁定端口
DatagramChannel serverChannel = DatagramChannel.open();
serverChannel.bind(new InetSocketAddress(9999)); // 綁定 UDP 端口
System.out.println("UDP 服務端啟動，監(jiān)聽 9999 端口...");
// 2. 創(chuàng)建緩沖區(qū)接收數(shù)據(jù)
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (true) {
// 3. 接收數(shù)據(jù)包（非阻塞模式下需檢查返回值）
InetSocketAddress clientAddress = (InetSocketAddress) serverChannel.receive(buffer);
if (clientAddress != null) {
buffer.flip(); // 切換為讀模式
byte[] data = newbyte[buffer.remaining()];
buffer.get(data); // 讀取數(shù)據(jù)到字節(jié)數(shù)組
System.out.println("收到來自 " + clientAddress + " 的消息: " + new String(data));
buffer.clear(); // 清空緩沖區(qū)，準備下次接收
}
}
}
}2.2 UDP 客戶端（發(fā)送數(shù)據(jù)）
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
import java.nio.charset.StandardCharsets;
publicclass UDPClient {
public static void main(String[] args) throws IOException {
// 1. 創(chuàng)建 DatagramChannel（無需綁定端口）
DatagramChannel clientChannel = DatagramChannel.open();
// 2. 準備發(fā)送的數(shù)據(jù)
String message = "Hello, UDP Server!";
ByteBuffer buffer = ByteBuffer.wrap(message.getBytes(StandardCharsets.UTF_8));
// 3. 發(fā)送數(shù)據(jù)到服務端
clientChannel.send(buffer, new InetSocketAddress("localhost", 9999));
System.out.println("消息已發(fā)送: " + message);
clientChannel.close(); // 關閉通道
}
}3. 高級用法：非阻塞模式 + Selector
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;
publicclass UDPNonBlockingServer {
public static void main(String[] args) throws IOException {
// 1. 創(chuàng)建 DatagramChannel 并設置為非阻塞模式
DatagramChannel channel = DatagramChannel.open();
channel.bind(new InetSocketAddress(9999));
channel.configureBlocking(false);
// 2. 創(chuàng)建 Selector 并注冊讀事件
Selector selector = Selector.open();
channel.register(selector, SelectionKey.OP_READ);
ByteBuffer buffer = ByteBuffer.allocate(1024);
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.isReadable()) {
// 3. 處理 UDP 數(shù)據(jù)包
DatagramChannel udpChannel = (DatagramChannel) key.channel();
InetSocketAddress clientAddress = (InetSocketAddress) udpChannel.receive(buffer);
if (clientAddress != null) {
buffer.flip();
byte[] data = newbyte[buffer.remaining()];
buffer.get(data);
System.out.println("收到數(shù)據(jù): " + new String(data));
buffer.clear();
}
}
}
}
}
}4. 關鍵點說明
- 綁定端口：服務端需調用 bind()，客戶端通常不需要。
- 緩沖區(qū)復用：每次接收后需 clear() 緩沖區(qū)。
- 非阻塞模式：
configureBlocking(false) 啟用非阻塞。
結合 Selector 實現(xiàn)多路復用（參考 NIO 的 TCP 用法）。
- 數(shù)據(jù)包無連接：UDP 不保證順序和可靠性，需應用層處理。
5. 適用場景
? 實時性要求高：音視頻流、游戲同步。? 輕量級通信：DNS 查詢、狀態(tài)心跳。? 廣播/組播：向多個客戶端發(fā)送相同數(shù)據(jù)。
?? 注意：若需可靠傳輸，建議在應用層實現(xiàn)重傳機制（如 QUIC 協(xié)議）。
1.3 Selector（選擇器）
圖片
- 作用：單線程管理多個 Channel，實現(xiàn)多路復用 I/O（類似 epoll）。
- 適用場景：高并發(fā)服務器（如聊天室、游戲服務器）。
- 事件類型：
OP_READ：可讀事件。
OP_WRITE：可寫事件。
OP_CONNECT：連接就緒。
OP_ACCEPT：接受新連接。
代碼片段（簡易非阻塞服務器） ：
Selector selector = Selector.open();
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.configureBlocking(false); // 非阻塞模式
serverChannel.register(selector, SelectionKey.OP_ACCEPT); // 注冊 accept 事件
while (true) {
selector.select(); // 阻塞等待事件
Set<SelectionKey> keys = selector.selectedKeys();
for (SelectionKey key : keys) {
if (key.isAcceptable()) { // 有新連接
SocketChannel client = serverChannel.accept();
client.configureBlocking(false);
client.register(selector, SelectionKey.OP_READ); // 監(jiān)聽讀事件
} elseif (key.isReadable()) { // 可讀數(shù)據(jù)
SocketChannel client = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(128);
client.read(buffer);
buffer.flip();
client.write(buffer); // 回顯數(shù)據(jù)
}
}
keys.clear();
}1.5 MappedByteBuffer(內存映射文件)
MappedByteBuffer 是 Java NIO 提供的一種 內存映射文件 技術，允許將文件直接映射到進程的虛擬內存空間，從而繞過傳統(tǒng)的 read()/write() 系統(tǒng)調用，實現(xiàn) 零拷貝 的高效文件訪問。特別適合處理 大文件隨機訪問 或 高頻讀寫 場景。
1.5.1 工作原理
圖片
1.5.2 基礎讀寫操作
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
publicclass MappedFileExample {
public static void main(String[] args) throws Exception {
// 1. 打開文件并獲取通道
RandomAccessFile file = new RandomAccessFile("test.dat", "rw");
FileChannel channel = file.getChannel();
// 2. 將文件映射到內存（模式：READ_WRITE，映射區(qū)域：0~1024字節(jié)）
MappedByteBuffer buffer = channel.map(
FileChannel.MapMode.READ_WRITE, // 讀寫模式
0, // 起始位置
1024 // 映射大小
);
// 3. 寫入數(shù)據(jù)（直接操作內存）
buffer.put("Hello, MappedByteBuffer!".getBytes());
// 4. 讀取數(shù)據(jù)
buffer.flip();
byte[] data = newbyte[buffer.remaining()];
buffer.get(data);
System.out.println(new String(data));
// 5. 關閉資源（buffer變化會自動同步到文件）
channel.close();
file.close();
}
}1.5.3 大文件分塊映射
// 分塊處理大文件（避免一次性映射整個文件）
long fileSize = channel.size();
long chunkSize = 1024 * 1024; // 1MB 分塊
long position = 0;
while (position < fileSize) {
long remaining = fileSize - position;
long size = Math.min(chunkSize, remaining);
MappedByteBuffer chunk = channel.map(
FileChannel.MapMode.READ_WRITE,
position,
size
);
// 處理當前分塊...
position += size;
}1.5.4 性能優(yōu)化技巧
(1) 使用 DirectByteBuffer
// 顯式使用直接緩沖區(qū)（減少一次拷貝）
ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);
channel.read(directBuffer);(2) 手動強制刷盤
MappedByteBuffer buffer = channel.map(...);
buffer.put(...);
buffer.force(); // 強制將更改寫入磁盤（類似 fsync）(3) 避免頻繁映射/解除映射
- 頻繁調用 map()/unmap() 會導致性能下降，盡量 復用已映射的緩沖區(qū)。
1.5.5 適用場景
推薦使用場景
? 大文件隨機讀寫（如數(shù)據(jù)庫索引文件）。? 高頻讀寫日志（如 Kafka 的 commit log）。? 進程間共享內存（需配合文件鎖）。
不適用場景
? 小文件處理（傳統(tǒng) I/O 更簡單）。? 只讀且順序訪問的文件（Files.readAllBytes() 更高效）。
1.5.6 底層原理
操作系統(tǒng)支持
- Linux/Unix：通過 mmap() 系統(tǒng)調用實現(xiàn)。
- Windows：通過 CreateFileMapping/MapViewOfFile 實現(xiàn)。
內存同步機制
- 寫入：修改 MappedByteBuffer 后，OS 異步將臟頁寫回磁盤（調用 force() 可強制同步）。
- 讀?。篛S 自動按需加載文件內容到頁緩存。
1.5.7 注意事項
- 資源釋放：
- MappedByteBuffer 本身無 close() 方法，需通過 FileChannel 或 RandomAccessFile 關閉。
- 解除映射依賴 GC 或手動調用 Cleaner（較復雜，通常無需處理）。
- 線程安全：
多線程操作同一 MappedByteBuffer 需自行同步（如 synchronized）。
虛擬內存限制：
避免映射超過物理內存的文件，否則可能觸發(fā)頻繁缺頁中斷。
1.5.8 性能對比
// 傳統(tǒng) I/O
FileInputStream fis = new FileInputStream("largefile.bin");
byte[] data = new byte[1024];
while (fis.read(data) != -1) { /* 處理數(shù)據(jù) */ }
// MappedByteBuffer
MappedByteBuffer buffer = channel.map(MapMode.READ_ONLY, 0, channel.size());
while (buffer.hasRemaining()) {
byte b = buffer.get(); // 直接內存訪問
}- 測試結果：對于 1GB 文件的順序讀取，MappedByteBuffer 比傳統(tǒng) I/O 快 3-5 倍。
2. NIO 的優(yōu)勢
? 高性能：單線程處理數(shù)千連接（減少線程切換開銷）。? 非阻塞：避免線程等待，提高吞吐量。? 零拷貝：FileChannel.transferTo() 直接傳輸文件（無需用戶態(tài)緩沖）。? 內存映射文件：MappedByteBuffer 加速大文件讀寫。
3. 適用場景
? 網(wǎng)絡服務器（如 Netty、Tomcat 底層使用 NIO）。? 大文件處理（內存映射文件）。? 低延遲應用（金融交易、實時通信）。
? 不適用：簡單的小文件讀寫（傳統(tǒng) I/O 更直觀）。
4. NIO 的擴展：NIO2（Java 7+）
Java 7 引入了 NIO.2，新增：
- Path 和 Files：替代 File 類，簡化文件操作。
- AsynchronousFileChannel：異步文件 I/O。
- WatchService：監(jiān)聽文件系統(tǒng)變更。
代碼片段（NIO2 讀取文件） ：
Path path = Paths.get("test.txt");
List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8); // 一行搞定
Files.write(path, "新內容".getBytes(), StandardOpenOption.APPEND);5. 小結
- NIO 核心：Buffer + Channel + Selector。
- 高并發(fā)秘訣：非阻塞 + 多路復用。
- NIO2 補充：更易用的文件 API（Path/Files）。
三、AIO
Java AIO（Asynchronous I/O，異步非阻塞 I/O）是 Java 7 引入的高性能 I/O 模型，基于事件回調和異步操作，適用于高吞吐量、低延遲的應用場景（如文件操作、網(wǎng)絡通信）。與 NIO 不同，AIO 不需要輪詢，操作系統(tǒng)會在 I/O 操作完成后主動通知應用。
1. AIO 核心組件
1.1 AsynchronousFileChannel（異步文件通道）
- 作用：異步讀寫文件，避免線程阻塞。
- 關鍵方法：
read() / write()：異步讀寫，通過 CompletionHandler 回調結果。
Future 模式：返回 Future 對象，可輪詢或阻塞等待結果。
代碼片段（異步文件讀?。?nbsp;：
Path path = Paths.get("test.txt");
AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(path);
ByteBuffer buffer = ByteBuffer.allocate(1024);
fileChannel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
@Override
public void completed(Integer result, ByteBuffer attachment) {
System.out.println("讀取完成，字節(jié)數(shù): " + result);
attachment.flip();
System.out.println(new String(attachment.array(), 0, result));
}
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
exc.printStackTrace();
}
});1.2 AsynchronousSocketChannel（異步網(wǎng)絡通道）
- 作用：異步 TCP 通信，支持非阻塞連接、讀寫。
- 關鍵方法：
connect()：異步連接服務器。
read() / write()：異步數(shù)據(jù)傳輸。
代碼片段（異步客戶端） ：
AsynchronousSocketChannel client = AsynchronousSocketChannel.open();
client.connect(new InetSocketAddress("127.0.0.1", 8080), null, new CompletionHandler<Void, Void>() {
@Override
public void completed(Void result, Void attachment) {
ByteBuffer buffer = ByteBuffer.wrap("Hello Server".getBytes());
client.write(buffer, null, new CompletionHandler<Integer, Void>() {
@Override
public void completed(Integer result, Void attachment) {
System.out.println("發(fā)送成功");
}
@Override
public void failed(Throwable exc, Void attachment) {
exc.printStackTrace();
}
});
}
@Override
public void failed(Throwable exc, Void attachment) {
exc.printStackTrace();
}
});1.3 CompletionHandler（回調接口）
- 核心接口：定義異步操作完成或失敗時的回調邏輯。
- 方法：
completed()：操作成功時觸發(fā)。
failed()：操作失敗時觸發(fā)。
2. AIO 工作機制
圖片
3. 使用場景
3.1 適合 AIO 的場景
? 高性能文件 I/O：大文件讀寫（如日志分析）。? 高并發(fā)網(wǎng)絡服務：WebSocket 服務器、金融交易系統(tǒng)。? 低延遲需求：實時通信（如游戲服務器）。
3.2 不適合 AIO 的場景
? 簡單應用：少量連接的 HTTP 服務（BIO/NIO 更簡單）。? 舊系統(tǒng)兼容：部分操作系統(tǒng)對 AIO 支持不完善（如 Windows）。
4. 代碼案例（AIO 服務器）
AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open();
server.bind(new InetSocketAddress(8080));
// 異步接受連接
server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
@Override
public void completed(AsynchronousSocketChannel client, Void attachment) {
server.accept(null, this); // 繼續(xù)接收新連接
ByteBuffer buffer = ByteBuffer.allocate(1024);
client.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
@Override
public void completed(Integer result, ByteBuffer attachment) {
attachment.flip();
client.write(attachment); // 回顯數(shù)據(jù)
}
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
exc.printStackTrace();
}
});
}
@Override
public void failed(Throwable exc, Void attachment) {
exc.printStackTrace();
}
});5. 小結
- AIO 優(yōu)勢：
真正的異步 I/O，依賴操作系統(tǒng)回調（無需輪詢）。
減少線程上下文切換，適合高吞吐場景。
- 注意事項：
代碼復雜度高，建議使用框架（如 Netty）。
Linux 需內核支持（epoll），Windows 通過 IOCP 實現(xiàn)。
?? 推薦框架：直接使用 Netty（封裝了 NIO/AIO 的最佳實踐），避免手動處理回調地獄。
四、對比分析
1. AIO vs. NIO vs. BIO
特性 | BIO | NIO | AIO |
阻塞模式 | 阻塞 | 非阻塞（需輪詢） | 非阻塞（回調通知） |
線程模型 | 一連接一線程 | 多路復用（Selector） | 回調驅動（無需輪詢） |
復雜度 | 簡單 | 中等（需管理 Buffer/Channel） | 高（需理解回調邏輯） |
適用場景 | 低并發(fā)短連接 | 高并發(fā)長連接 | 高吞吐量、低延遲（如 Proactor 模式） |
操作系統(tǒng)支持 | 所有平臺 | 所有平臺 | 依賴操作系統(tǒng)（Linux 需 epoll） |
2. NIO 與 BIO（線程池優(yōu)化）的本質區(qū)別
NIO 和 BIO（線程池優(yōu)化版）表面上看都是“用少量線程處理多連接” ，但兩者的底層設計思想、性能上限和適用場景有根本性差異
2.1 BIO 線程池的偽多路復用
// BIO 線程池偽代碼（表面多路復用，實際仍是阻塞式）
ExecutorService pool = Executors.newFixedThreadPool(100);
while (true) {
Socket socket = serverSocket.accept(); // 阻塞等待連接
pool.execute(() -> {
InputStream in = socket.getInputStream();
in.read(); // 線程仍阻塞在這里！
});
}- 本質問題：
每個線程仍會阻塞在 read() 上，線程池只是限制了最大線程數(shù)。
當 100 個線程全部阻塞時，第 101 個連接必須等待線程釋放。
2.2 NIO 的真·多路復用
// NIO 真·多路復用（單線程管理所有連接）
Selector selector = Selector.open();
channel.register(selector, SelectionKey.OP_READ);
while (true) {
selector.select(); // 阻塞直到任意連接有數(shù)據(jù)
Set<SelectionKey> keys = selector.selectedKeys();
for (SelectionKey key : keys) {
if (key.isReadable()) {
// 只有數(shù)據(jù)就緒的連接會被處理
SocketChannel client = (SocketChannel) key.channel();
client.read(buffer); // 非阻塞讀取
}
}
}- 核心優(yōu)勢：
單線程即可處理數(shù)萬連接（僅活躍連接消耗 CPU）。
完全避免線程阻塞在 I/O 上，操作系統(tǒng)事件通知機制（如 epoll）負責監(jiān)聽就緒狀態(tài)。
2.3 性能對比圖
BIO 線程池模型
圖片
NIO 多路復用模型
圖片
2.4. 關鍵結論
- BIO 線程池優(yōu)化：
- 只是限制了線程數(shù)量，無法解決阻塞 I/O 的本質問題。
- 適合 低并發(fā)短連接（如 HTTP/1.0），但不適合長連接或高并發(fā)。
- NIO 多路復用：
通過操作系統(tǒng)事件通知（如 epoll/kqueue）實現(xiàn) 真正的非阻塞。
適合 高并發(fā)長連接（如 WebSocket、游戲服務器）。
性能差距：
BIO 線程池：1k 并發(fā)需要 ≈1k 線程（線程切換開銷爆炸）。
NIO：1-2 個線程即可處理 10k+ 并發(fā)（如 Netty 默認配置）。
