高级java每日一道面试题-2025年6月03日-基础篇[NIO篇]-Java NIO 深度解析与面试指南

Java NIO 深度解析与面试指南

一、Java NIO 核心架构解析

1.1 NIO 设计哲学：三个核心概念

Java NIO 的核心是 Channel（通道）、Buffer（缓冲区） 和 Selector（选择器） 三者的协同工作：

public class NIOCoreConcepts {
/**
* NIO 的核心理念：
* 1. Channel: 双向的流，可以读也可以写（对比传统I/O的InputStream/OutputStream）
* 2. Buffer: 数据容器，Channel的所有操作都通过Buffer
* 3. Selector: 多路复用器，单线程管理多个Channel
*/

// NIO 工作流程图示
class NIOWorkflow {
/*
传统BIO模型： NIO模型：
线程1 -> Socket1 线程 -> Selector
线程2 -> Socket2 ↓
线程3 -> Socket3 Channel1 Channel2 Channel3
(线程数 = 连接数) (单线程管理多个连接)
*/
}
}

1.2 NIO vs BIO 全面对比

public class NIOvsBIOComparison {

// 详细对比表格
class ComparisonTable {
/*
| 维度 | BIO (Blocking I/O) | NIO (New I/O / Non-blocking I/O) |
|——|——————-|———————————–|
| 工作模式 | 阻塞式 | 非阻塞式 |
| 处理单位 | 流(Stream) | 块(Buffer) |
| 线程模型 | 1连接1线程 | 1线程多连接 |
| 系统调用 | read()/write() | select()/poll()/epoll() |
| 内存管理 | JVM堆内存 | 堆外直接内存 |
| 使用复杂度 | 简单直观 | 相对复杂 |
| 适用场景 | 连接数少、短连接 | 连接数多、长连接 |
| 吞吐量 | 低 | 高 |
*/
}

// 底层原理差异
class UnderlyingPrinciples {
void bioModel() {
/* BIO 工作流程：
* 1. 应用程序调用read()
* 2. 内核等待数据到达
* 3. 数据到达后拷贝到用户空间
* 4. read()返回
* 问题：整个过程线程都被阻塞
*/
}

void nioModel() {
/* NIO 工作流程：
* 1. 应用程序调用read()，立即返回
* 2. 内核准备数据（异步）
* 3. 应用程序轮询检查数据是否就绪
* 4. 数据就绪后拷贝到用户空间
* 优势：线程在等待期间可以做其他事情
*/
}
}
}

二、Buffer（缓冲区）深度解析

2.1 Buffer 的核心状态机

public class BufferDeepDive {

// Buffer 的四个核心属性
class BufferStateMachine {
/*
* Buffer 状态变迁：
*
* 初始状态: position=0, limit=capacity, mark=-1
*
* 写数据 → flip() → 读数据 → clear()/compact() → 写数据
* ↓
* rewind() → 重新读
* ↓
* mark() → reset() → 回到标记位置
*/

// Buffer 状态演示
void demonstrateBufferStates() {
ByteBuffer buffer = ByteBuffer.allocate(10);

System.out.println("初始状态:");
printBufferState(buffer); // position=0, limit=10, capacity=10

// 写入数据
buffer.put((byte) 'H');
buffer.put((byte) 'e');
buffer.put((byte) 'l');
buffer.put((byte) 'l');
buffer.put((byte) 'o');

System.out.println("\\n写入5个字节后:");
printBufferState(buffer); // position=5, limit=10

// 切换到读模式
buffer.flip();

System.out.println("\\nflip()切换到读模式后:");
printBufferState(buffer); // position=0, limit=5

// 读取2个字节
System.out.println("\\n读取2个字节:");
System.out.println((char) buffer.get()); // H
System.out.println((char) buffer.get()); // e
printBufferState(buffer); // position=2, limit=5

// 标记当前位置
buffer.mark(); // position=2

// 继续读取
System.out.println("\\n再读取2个字节:");
System.out.println((char) buffer.get()); // l
System.out.println((char) buffer.get()); // l
printBufferState(buffer); // position=4

// 重置到标记位置
buffer.reset();
System.out.println("\\nreset()回到标记位置:");
printBufferState(buffer); // position=2

// 重新读取所有数据
buffer.rewind();
System.out.println("\\nrewind()后:");
printBufferState(buffer); // position=0, limit=5

// 清空缓冲区（切换到写模式，但保留数据）
buffer.clear();
System.out.println("\\nclear()后:");
printBufferState(buffer); // position=0, limit=10

// compact()：压缩缓冲区，保留未读数据
buffer.put("Hello".getBytes());
buffer.flip();
buffer.get(); // 读取'H'
buffer.compact(); // 将剩余"ello"移动到缓冲区开头
System.out.println("\\ncompact()后:");
printBufferState(buffer); // position=4, limit=10
}

void printBufferState(ByteBuffer buffer) {
System.out.printf("position=%d, limit=%d, capacity=%d%n",
buffer.position(), buffer.limit(), buffer.capacity());
}
}

// 直接缓冲区 vs 堆缓冲区
class DirectVsHeapBuffer {
void compareBufferTypes() {
/*
* 堆缓冲区 (Heap Buffer):
* – ByteBuffer.allocate(capacity)
* – 在JVM堆内存中分配
* – 受到GC管理
* – 性能：中等
*
* 直接缓冲区 (Direct Buffer):
* – ByteBuffer.allocateDirect(capacity)
* – 在堆外内存分配（不受GC管理）
* – 创建和销毁成本高
* – 性能：高（减少一次内存拷贝）
* – 适合：大文件、频繁I/O操作
*/

// 性能对比测试
int size = 1024 * 1024; // 1MB
int iterations = 1000;

// 测试堆缓冲区
long heapStart = System.nanoTime();
for (int i = 0; i < iterations; i++) {
ByteBuffer heapBuffer = ByteBuffer.allocate(size);
// 模拟I/O操作
}
long heapTime = System.nanoTime() – heapStart;

// 测试直接缓冲区
long directStart = System.nanoTime();
for (int i = 0; i < iterations; i++) {
ByteBuffer directBuffer = ByteBuffer.allocateDirect(size);
// 模拟I/O操作
}
long directTime = System.nanoTime() – directStart;

System.out.printf("堆缓冲区: %.2f ms, 直接缓冲区: %.2f ms%n",
heapTime / 1_000_000.0, directTime / 1_000_000.0);

// 使用建议
System.out.println("\\n使用建议：");
System.out.println("- 频繁I/O操作 → 使用直接缓冲区");
System.out.println("- 小缓冲区、短生命周期 → 使用堆缓冲区");
System.out.println("- 需要与JNI交互 → 使用直接缓冲区");
}
}

// 视图缓冲区（View Buffer）
class ViewBuffers {
void demonstrateViewBuffers() {
ByteBuffer byteBuffer = ByteBuffer.allocate(16);

// 写入不同类型的数据
byteBuffer.putInt(100); // 4字节
byteBuffer.putDouble(3.14); // 8字节
byteBuffer.putChar('A'); // 2字节
byteBuffer.putShort((short) 42); // 2字节

// 重置position准备读取
byteBuffer.flip();

// 创建视图缓冲区（共享底层数据）
IntBuffer intBuffer = byteBuffer.asIntBuffer();
DoubleBuffer doubleBuffer = byteBuffer.asDoubleBuffer();
CharBuffer charBuffer = byteBuffer.asCharBuffer();
ShortBuffer shortBuffer = byteBuffer.asShortBuffer();

// 通过视图读取数据
System.out.println("Int: " + intBuffer.get()); // 100
System.out.println("Double: " + doubleBuffer.get());// 3.14

// 注意：视图的位置是独立的
System.out.println("Char: " + charBuffer.get()); // 'A'
System.out.println("Short: " + shortBuffer.get()); // 42

// 只读视图
ByteBuffer readOnlyBuffer = byteBuffer.asReadOnlyBuffer();
try {
readOnlyBuffer.put((byte) 1); // 抛出ReadOnlyBufferException
} catch (ReadOnlyBufferException e) {
System.out.println("只读缓冲区不能修改");
}
}
}
}

2.2 Buffer 的最佳实践

public class BufferBestPractices {

// 缓冲区复用模式（减少GC压力）
class BufferPool {
private final ConcurrentLinkedQueue<ByteBuffer> bufferPool =
new ConcurrentLinkedQueue<>();
private final int bufferSize;

public BufferPool(int bufferSize, int initialCapacity) {
this.bufferSize = bufferSize;
for (int i = 0; i < initialCapacity; i++) {
bufferPool.offer(ByteBuffer.allocate(bufferSize));
}
}

public ByteBuffer borrowBuffer() {
ByteBuffer buffer = bufferPool.poll();
if (buffer == null) {
buffer = ByteBuffer.allocate(bufferSize);
}
buffer.clear(); // 重置状态
return buffer;
}

public void returnBuffer(ByteBuffer buffer) {
if (buffer != null && buffer.capacity() == bufferSize) {
buffer.clear();
bufferPool.offer(buffer);
}
}
}

// 批量操作优化
class BatchOperations {
void bulkTransferExample() {
// 创建源和目标缓冲区
ByteBuffer source = ByteBuffer.allocate(1024);
ByteBuffer destination = ByteBuffer.allocate(1024);

// 填充源数据
for (int i = 0; i < 256; i++) {
source.put((byte) i);
}
source.flip();

// 批量传输（比逐个put更高效）
destination.put(source);

// 或者使用批量get/put
byte[] array = new byte[256];
source.get(array); // 批量读取到数组
destination.put(array); // 批量写入

// 使用 transferTo/transferFrom（Channel之间）
try (FileChannel srcChannel = new FileInputStream("src.txt").getChannel();
FileChannel destChannel = new FileOutputStream("dest.txt").getChannel()) {

// 零拷贝传输
srcChannel.transferTo(0, srcChannel.size(), destChannel);
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

三、Channel（通道）深度解析

3.1 各种 Channel 的详细对比

public class ChannelDeepDive {

// Channel 类型对比
class ChannelComparison {
/*
| Channel 类型 | 方向 | 阻塞模式 | 主要用途 |
|————-|——|———|———-|
| FileChannel | 双向 | 支持 | 文件I/O，支持内存映射 |
| SocketChannel | 双向 | 支持 | TCP客户端 |
| ServerSocketChannel | 单向(接受) | 支持 | TCP服务器 |
| DatagramChannel | 双向 | 支持 | UDP通信 |
| AsynchronousFileChannel | 双向 | 异步 | 异步文件I/O |
| AsynchronousSocketChannel | 双向 | 异步 | 异步TCP客户端 |
| AsynchronousServerSocketChannel | 单向 | 异步 | 异步TCP服务器 |
*/
}

// FileChannel 高级功能
class FileChannelFeatures {
void demonstrateFileChannel() throws IOException {
// 1. 打开文件的多种方式
Path path = Paths.get("test.txt");

// 方式1：传统方式
try (FileChannel channel = new FileInputStream("test.txt").getChannel()) {
// 读取文件
}

// 方式2：NIO.2方式（推荐）
try (FileChannel channel = FileChannel.open(path,
StandardOpenOption.READ,
StandardOpenOption.WRITE,
StandardOpenOption.CREATE)) {
// 多种操作…

// 2. 文件锁定
FileLock lock = channel.lock(); // 排他锁
// FileLock sharedLock = channel.lock(0, Long.MAX_VALUE, true); // 共享锁

try {
// 执行文件操作
channel.write(ByteBuffer.wrap("Hello".getBytes()));
} finally {
lock.release();
}

// 3. 强制写入磁盘
channel.force(true); // 包括元数据

// 4. 截断文件
channel.truncate(100); // 保留前100字节

// 5. 获取文件大小
long size = channel.size();

// 6. 设置文件位置
channel.position(50); // 移动到第50字节
}
}
}

// SocketChannel 与 ServerSocketChannel
class SocketChannelExamples {
// 非阻塞TCP客户端
void nonBlockingClient() throws IOException {
SocketChannel clientChannel = SocketChannel.open();
clientChannel.configureBlocking(false); // 非阻塞模式

// 异步连接
boolean connected = clientChannel.connect(
new InetSocketAddress("localhost", 8080));

if (!connected) {
// 连接正在进行中，可以做其他事情
while (!clientChannel.finishConnect()) {
System.out.println("连接中…可以做其他事情");
Thread.yield();
}
}

// 连接完成，开始通信
ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.put("Hello Server".getBytes());
buffer.flip();

while (buffer.hasRemaining()) {
clientChannel.write(buffer);
}

// 读取响应
buffer.clear();
int bytesRead = clientChannel.read(buffer);
if (bytesRead > 0) {
buffer.flip();
byte[] data = new byte[buffer.remaining()];
buffer.get(data);
System.out.println("收到响应: " + new String(data));
}

clientChannel.close();
}

// 非阻塞TCP服务器
void nonBlockingServer() throws IOException {
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false); // 非阻塞模式
serverChannel.bind(new InetSocketAddress(8080));

Selector selector = Selector.open();
serverChannel.register(selector, SelectionKey.OP_ACCEPT);

System.out.println("服务器启动在端口 8080");

while (true) {
int readyChannels = selector.select(); // 阻塞直到有事件
if (readyChannels == 0) continue;

Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

while (keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();

if (key.isAcceptable()) {
// 接受新连接
ServerSocketChannel server = (ServerSocketChannel) key.channel();
SocketChannel clientChannel = server.accept();
clientChannel.configureBlocking(false);

// 注册读事件
clientChannel.register(selector, SelectionKey.OP_READ);
System.out.println("接受新连接: " +
clientChannel.getRemoteAddress());

} else if (key.isReadable()) {
// 读取客户端数据
SocketChannel clientChannel = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);

int bytesRead = clientChannel.read(buffer);
if (bytesRead == –1) {
// 连接关闭
clientChannel.close();
} else if (bytesRead > 0) {
buffer.flip();
byte[] data = new byte[buffer.remaining()];
buffer.get(data);

System.out.println("收到: " + new String(data));

// 回显数据
buffer.clear();
buffer.put(("Echo: " + new String(data)).getBytes());
buffer.flip();
clientChannel.write(buffer);
}

} else if (key.isWritable()) {
// 可写事件
// 通常在有大量数据要写时注册此事件
}

keyIterator.remove(); // 处理完移除
}
}
}
}

// DatagramChannel (UDP)
class DatagramChannelExample {
void demonstrateUDP() throws IOException {
// 客户端
DatagramChannel clientChannel = DatagramChannel.open();
clientChannel.configureBlocking(false);

// 发送数据
ByteBuffer sendBuffer = ByteBuffer.wrap("Hello UDP".getBytes());
clientChannel.send(sendBuffer,
new InetSocketAddress("localhost", 9999));

// 接收数据
ByteBuffer receiveBuffer = ByteBuffer.allocate(1024);
SocketAddress serverAddress = clientChannel.receive(receiveBuffer);

if (serverAddress != null) {
receiveBuffer.flip();
byte[] data = new byte[receiveBuffer.remaining()];
receiveBuffer.get(data);
System.out.println("收到UDP响应: " + new String(data));
}

// 连接到特定地址（TCP风格的使用方式）
clientChannel.connect(new InetSocketAddress("localhost", 9999));
// 连接后可以使用read()/write()而不是send()/receive()

clientChannel.close();
}
}
}

3.2 Channel 的分散（Scatter）和聚集（Gather）

public class ScatterGatherExample {

// 分散读（Scattering Read）：将数据读到多个缓冲区
void scatteringRead() throws IOException {
try (FileChannel channel = new FileInputStream("data.txt").getChannel()) {
// 创建多个缓冲区
ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body = ByteBuffer.allocate(1024);
ByteBuffer trailer = ByteBuffer.allocate(64);

ByteBuffer[] buffers = {header, body, trailer};

// 分散读取：按顺序填充缓冲区
long bytesRead = channel.read(buffers);

System.out.println("总共读取: " + bytesRead + " 字节");
System.out.println("头部: " + header.position() + " 字节");
System.out.println("主体: " + body.position() + " 字节");
System.out.println("尾部: " + trailer.position() + " 字节");

// 处理各个缓冲区
header.flip();
processHeader(header);

body.flip();
processBody(body);

trailer.flip();
processTrailer(trailer);
}
}

// 聚集写（Gathering Write）：从多个缓冲区写数据
void gatheringWrite() throws IOException {
try (FileChannel channel = new FileOutputStream("output.txt").getChannel()) {
// 创建多个缓冲区
ByteBuffer header = ByteBuffer.wrap("HEADER:".getBytes());
ByteBuffer body = ByteBuffer.wrap("This is the body content".getBytes());
ByteBuffer footer = ByteBuffer.wrap("END".getBytes());

ByteBuffer[] buffers = {header, body, footer};

// 聚集写入：按顺序写入所有缓冲区的内容
long bytesWritten = channel.write(buffers);

System.out.println("总共写入: " + bytesWritten + " 字节");
}
}

// 实际应用：消息帧解析
class MessageFraming {
// 使用分散读解析固定格式的消息
void parseMessageFrame(ByteBuffer buffer) {
// 假设消息格式：4字节长度 + n字节数据 + 2字节CRC
buffer.flip();

// 创建分散缓冲区
ByteBuffer lengthBuffer = ByteBuffer.allocate(4);
ByteBuffer dataBuffer = ByteBuffer.allocate(buffer.remaining() – 6);
ByteBuffer crcBuffer = ByteBuffer.allocate(2);

ByteBuffer[] buffers = {lengthBuffer, dataBuffer, crcBuffer};

// 模拟分散读（实际从channel读取）
int position = 0;
for (ByteBuffer buf : buffers) {
int limit = Math.min(buf.remaining(), buffer.remaining() – position);
byte[] temp = new byte[limit];
buffer.get(temp);
buf.put(temp);
position += limit;
}

// 处理各个部分
lengthBuffer.flip();
int length = lengthBuffer.getInt();

dataBuffer.flip();
byte[] data = new byte[dataBuffer.remaining()];
dataBuffer.get(data);

crcBuffer.flip();
short crc = crcBuffer.getShort();

System.out.println("消息长度: " + length);
System.out.println("数据: " + new String(data));
System.out.println("CRC: " + crc);
}
}
}

四、Selector（选择器）深度解析

4.1 Selector 的工作原理

public class SelectorDeepDive {

// Selector 状态模型
class SelectorStateModel {
/*
* Selector 核心概念：
*
* 1. 注册 (Register): Channel 注册到 Selector，指定关注的事件
* 2. 选择 (Select): 检查哪些Channel有就绪事件
* 3. 选择键 (SelectionKey): 表示Channel在Selector中的注册
* 4. 就绪集合 (Selected Set): 有就绪事件的SelectionKey集合
*
* 事件类型：
* – OP_READ: 读就绪
* – OP_WRITE: 写就绪
* – OP_CONNECT: 连接就绪
* – OP_ACCEPT: 接受就绪
*/
}

// Selector 的完整工作流程
class SelectorWorkflow {
void demonstrateCompleteWorkflow() throws IOException {
// 1. 创建Selector
Selector selector = Selector.open();

// 2. 创建ServerSocketChannel并注册
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false);
serverChannel.bind(new InetSocketAddress(8080));

SelectionKey serverKey = serverChannel.register(
selector, SelectionKey.OP_ACCEPT);

// 3. 可以设置附件（传递数据）
serverKey.attach(new ServerContext("Server-1"));

System.out.println("服务器启动，等待连接…");

while (true) {
// 4. 选择就绪的通道（阻塞方法）
int readyCount = selector.select(); // 可以设置超时：selector.select(1000)

if (readyCount == 0) {
System.out.println("没有就绪的通道，继续等待…");
continue;
}

// 5. 获取就绪的SelectionKey集合
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

while (keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();

// 6. 处理事件
try {
if (key.isValid()) {
if (key.isAcceptable()) {
handleAccept(key);
} else if (key.isConnectable()) {
handleConnect(key);
} else if (key.isReadable()) {
handleRead(key);
} else if (key.isWritable()) {
handleWrite(key);
}
} else {
// 无效的key，取消注册
key.cancel();
}
} catch (IOException e) {
// 处理异常，取消key
key.cancel();
try {
key.channel().close();
} catch (IOException ex) {
// 忽略关闭异常
}
}

// 7. 从集合中移除已处理的key
keyIterator.remove();
}

// 8. 处理取消的key（可选）
selector.selectNow(); // 非阻塞调用，处理取消的key
}
}

private void handleAccept(SelectionKey key) throws IOException {
ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
SocketChannel clientChannel = serverChannel.accept();
clientChannel.configureBlocking(false);

// 注册读事件
SelectionKey clientKey = clientChannel.register(
key.selector(), SelectionKey.OP_READ);

// 为客户端连接设置附件（缓冲区）
clientKey.attach(ByteBuffer.allocate(1024));

System.out.println("接受新连接: " +
clientChannel.getRemoteAddress());
}

private void handleRead(SelectionKey key) throws IOException {
SocketChannel channel = (SocketChannel) key.channel();
ByteBuffer buffer = (ByteBuffer) key.attachment();

buffer.clear();
int bytesRead = channel.read(buffer);

if (bytesRead == –1) {
// 连接关闭
channel.close();
System.out.println("连接关闭: " + channel.getRemoteAddress());
} else if (bytesRead > 0) {
buffer.flip();

// 处理数据
byte[] data = new byte[buffer.remaining()];
buffer.get(data);
String message = new String(data);

System.out.println("收到消息: " + message);

// 如果需要回写，注册写事件
key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);

// 存储响应数据
ByteBuffer response = ByteBuffer.wrap(
("Echo: " + message).getBytes());
key.attach(response);
}
}

private void handleWrite(SelectionKey key) throws IOException {
SocketChannel channel = (SocketChannel) key.channel();
ByteBuffer buffer = (ByteBuffer) key.attachment();

if (buffer != null && buffer.hasRemaining()) {
int bytesWritten = channel.write(buffer);
System.out.println("写入 " + bytesWritten + " 字节");

if (!buffer.hasRemaining()) {
// 写完了，取消写事件，只关注读事件
key.interestOps(SelectionKey.OP_READ);
key.attach(null); // 清理附件
}
}
}

private void handleConnect(SelectionKey key) throws IOException {
SocketChannel channel = (SocketChannel) key.channel();

if (channel.finishConnect()) {
System.out.println("连接建立: " + channel.getRemoteAddress());

// 连接建立后，可以开始读写
key.interestOps(SelectionKey.OP_READ);

// 发送初始数据
ByteBuffer buffer = ByteBuffer.wrap("Hello Server".getBytes());
channel.write(buffer);
} else {
// 连接失败
key.cancel();
channel.close();
}
}
}

class ServerContext {
String serverName;

public ServerContext(String serverName) {
this.serverName = serverName;
}
}
}

4.2 Selector 的高级特性

public class SelectorAdvancedFeatures {

// 多Selector负载均衡
class MultiSelectorLoadBalancer {
private final Selector[] selectors;
private int currentIndex = 0;

public MultiSelectorLoadBalancer(int count) throws IOException {
selectors = new Selector[count];
for (int i = 0; i < count; i++) {
selectors[i] = Selector.open();
}
}

// 轮询分配Selector
public Selector nextSelector() {
Selector selector = selectors[currentIndex];
currentIndex = (currentIndex + 1) % selectors.length;
return selector;
}

// 启动多个选择器线程
public void start() {
for (int i = 0; i < selectors.length; i++) {
final int index = i;
Thread thread = new Thread(() -> {
try {
runSelectorLoop(selectors[index], "Selector-" + index);
} catch (IOException e) {
e.printStackTrace();
}
});
thread.setDaemon(true);
thread.start();
}
}

private void runSelectorLoop(Selector selector, String name)
throws IOException {
System.out.println(name + " 启动");

while (!Thread.interrupted()) {
int readyChannels = selector.select();
if (readyChannels == 0) continue;

Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> iterator = keys.iterator();

while (iterator.hasNext()) {
SelectionKey key = iterator.next();
iterator.remove();

if (key.isValid()) {
// 处理事件…
}
}
}
}
}

// Selector 唤醒机制
class SelectorWakeup {
void demonstrateWakeup() throws IOException, InterruptedException {
Selector selector = Selector.open();

// 创建唤醒通道
Pipe pipe = Pipe.open();
pipe.source().configureBlocking(false);
pipe.source().register(selector, SelectionKey.OP_READ);

// 启动选择线程
Thread selectThread = new Thread(() -> {
try {
while (true) {
System.out.println("选择线程: 等待事件…");
selector.select();

Set<SelectionKey> keys = selector.selectedKeys();
for (SelectionKey key : keys) {
if (key.isReadable() &&
key.channel() == pipe.source()) {
System.out.println("选择线程: 被唤醒");

// 读取唤醒信号
ByteBuffer buffer = ByteBuffer.allocate(1);
pipe.source().read(buffer);

// 处理唤醒后的逻辑
handleWakeup();
}
}
keys.clear();
}
} catch (IOException e) {
e.printStackTrace();
}
});

selectThread.start();

// 主线程在某个时刻唤醒选择器
Thread.sleep(2000);
System.out.println("主线程: 唤醒选择器");

ByteBuffer buffer = ByteBuffer.wrap(new byte[]{1});
pipe.sink().write(buffer);

Thread.sleep(1000);

// 使用selector.wakeup()方法（更常用）
System.out.println("主线程: 再次唤醒选择器");
selector.wakeup();
}

private void handleWakeup() {
System.out.println("处理唤醒事件");
}
}

// 选择键的取消和清理
class KeyCancellation {
void demonstrateCancellation() throws IOException {
Selector selector = Selector.open();
SocketChannel channel = SocketChannel.open();
channel.configureBlocking(false);

// 注册通道
SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

// 取消key的几种方式
System.out.println("Key 有效: " + key.isValid()); // true

// 方式1: key.cancel()
key.cancel();
System.out.println("取消后 Key 有效: " + key.isValid()); // false

// 方式2: channel.close() 会自动取消所有相关的key
channel = SocketChannel.open();
channel.configureBlocking(false);
key = channel.register(selector, SelectionKey.OP_READ);

channel.close();
System.out.println("通道关闭后 Key 有效: " + key.isValid()); // false

// 方式3: selector.close() 会取消所有key
selector = Selector.open();
channel = SocketChannel.open();
channel.configureBlocking(false);
key = channel.register(selector, SelectionKey.OP_READ);

selector.close();
System.out.println("Selector关闭后 Key 有效: " + key.isValid()); // false

// 清理已取消的key
selector = Selector.open();
for (int i = 0; i < 10; i++) {
channel = SocketChannel.open();
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_READ).cancel();
channel.close();
}

System.out.println("取消的Key数量: " + countCancelledKeys(selector));

// 调用selectNow()会清理已取消的key
selector.selectNow();
System.out.println("selectNow()后取消的Key数量: " +
countCancelledKeys(selector));
}

private int countCancelledKeys(Selector selector) {
int count = 0;
for (SelectionKey key : selector.keys()) {
if (!key.isValid()) {
count++;
}
}
return count;
}
}
}

五、内存映射文件（MappedByteBuffer）

5.1 内存映射原理与使用

public class MappedByteBufferDeepDive {

// 内存映射的工作原理
class MemoryMappingPrinciples {
void explainMemoryMapping() {
/*
* 内存映射文件原理：
*
* 传统文件I/O:
* 1. 用户空间发起read()系统调用
* 2. 内核读取文件到内核缓冲区
* 3. 数据从内核缓冲区拷贝到用户缓冲区
* 4. read()返回
*
* 内存映射文件:
* 1. mmap()系统调用将文件映射到进程地址空间
* 2. 访问文件就像访问内存一样
* 3. 缺页中断时，内核自动加载数据
* 4. 修改自动写回文件（取决于映射模式）
*
* 优势：
* – 减少系统调用
* – 减少内存拷贝
* – 随机访问高效
* – 共享内存通信
*/
}
}

// 内存映射文件的使用
class MappedFileOperations {
void demonstrateMappedFile() throws IOException {
Path filePath = Paths.get("largefile.dat");

// 1. 创建或打开文件
if (!Files.exists(filePath)) {
Files.createFile(filePath);
}

// 2. 打开FileChannel
try (FileChannel channel = FileChannel.open(filePath,
StandardOpenOption.READ,
StandardOpenOption.WRITE,
StandardOpenOption.CREATE)) {

// 3. 创建内存映射
// 映射模式：
// – READ_ONLY: 只读
// – READ_WRITE: 可读写
// – PRIVATE: 写时复制（修改不影响原文件）

long fileSize = 1024 * 1024 * 100; // 100MB
if (channel.size() < fileSize) {
channel.truncate(fileSize);
}

MappedByteBuffer mappedBuffer = channel.map(
FileChannel.MapMode.READ_WRITE, 0, fileSize);

System.out.println("内存映射创建完成");
System.out.println("容量: " + mappedBuffer.capacity() + " 字节");
System.out.println("是否直接缓冲区: " + mappedBuffer.isDirect());

// 4. 像操作普通ByteBuffer一样操作内存映射
// 写入数据
mappedBuffer.position(0);
mappedBuffer.put("Hello Memory Mapping".getBytes());

// 读取数据
mappedBuffer.position(0);
byte[] data = new byte[20];
mappedBuffer.get(data);
System.out.println("读取: " + new String(data));

// 5. 修改数据（自动同步到文件）
mappedBuffer.put(0, (byte) 'h'); // 修改第一个字符

// 6. 强制同步到磁盘
mappedBuffer.force(); // 等同于 channel.force()

// 7. 性能测试：顺序访问 vs 随机访问
testAccessPatterns(mappedBuffer);

// 8. 注意事项：不要unmap，由GC自动处理
// 如果需要立即释放，可以：
// – 设置buffer引用为null
// – 调用System.gc()（不推荐）
// – 使用Cleaner（高级技巧）
}
}

void testAccessPatterns(MappedByteBuffer buffer) {
int size = buffer.capacity();
long startTime, endTime;

// 顺序访问测试
startTime = System.nanoTime();
for (int i = 0; i < size; i++) {
buffer.get(i); // 顺序读取每个字节
}
endTime = System.nanoTime();
System.out.printf("顺序访问时间: %.2f ms%n",
(endTime – startTime) / 1_000_000.0);

// 随机访问测试
Random random = new Random();
startTime = System.nanoTime();
for (int i = 0; i < 10000; i++) {
int pos = random.nextInt(size);
buffer.get(pos); // 随机位置读取
}
endTime = System.nanoTime();
System.out.printf("随机访问时间: %.2f ms%n",
(endTime – startTime) / 1_000_000.0);
}
}

// 内存映射的高级应用
class AdvancedMappedFile {
// 内存映射文件数据库
class MappedFileDatabase {
private MappedByteBuffer dataBuffer;
private MappedByteBuffer indexBuffer;
private final int recordSize = 100; // 每条记录100字节
private final int indexEntrySize = 12; // 索引条目：4字节key + 8字节offset

public void openDatabase(String dataFile, String indexFile)
throws IOException {
// 映射数据文件
try (FileChannel dataChannel = FileChannel.open(
Paths.get(dataFile),
StandardOpenOption.READ,
StandardOpenOption.WRITE,
StandardOpenOption.CREATE)) {

long dataSize = 1024 * 1024 * 100; // 100MB
dataBuffer = dataChannel.map(
FileChannel.MapMode.READ_WRITE, 0, dataSize);
}

// 映射索引文件
try (FileChannel indexChannel = FileChannel.open(
Paths.get(indexFile),
StandardOpenOption.READ,
StandardOpenOption.WRITE,
StandardOpenOption.CREATE)) {

long indexSize = 1024 * 1024; // 1MB
indexBuffer = indexChannel.map(
FileChannel.MapMode.READ_WRITE, 0, indexSize);
}
}

public void put(int key, byte[] value) {
if (value.length > recordSize) {
throw new IllegalArgumentException("值太大");
}

// 在数据文件中分配位置
long dataOffset = allocateDataSpace(value.length);

// 写入数据
dataBuffer.position((int) dataOffset);
dataBuffer.putInt(value.length); // 写入长度
dataBuffer.put(value); // 写入数据

// 更新索引
updateIndex(key, dataOffset);
}

public byte[] get(int key) {
// 从索引查找数据位置
Long dataOffset = findInIndex(key);
if (dataOffset == null) {
return null;
}

// 读取数据
dataBuffer.position(dataOffset.intValue());
int length = dataBuffer.getInt();
byte[] value = new byte[length];
dataBuffer.get(value);

return value;
}

private long allocateDataSpace(int size) {
// 简单的空间分配：返回当前位置
long position = dataBuffer.position();
dataBuffer.position((int) (position + size + 4)); // +4用于存储长度
return position;
}

private void updateIndex(int key, long offset) {
// 简单的线性索引（实际应该用B+树等）
int indexPos = 0;
while (indexPos < indexBuffer.capacity()) {
int currentKey = indexBuffer.getInt(indexPos);
if (currentKey == 0) { // 空槽
indexBuffer.putInt(indexPos, key);
indexBuffer.putLong(indexPos + 4, offset);
break;
}
indexPos += indexEntrySize;
}
}

private Long findInIndex(int key) {
int indexPos = 0;
while (indexPos < indexBuffer.capacity()) {
int currentKey = indexBuffer.getInt(indexPos);
if (currentKey == key) {
return indexBuffer.getLong(indexPos + 4);
} else if (currentKey == 0) {
break; // 到达索引末尾
}
indexPos += indexEntrySize;
}
return null;
}
}

// 内存映射文件共享
class SharedMemory {
void demonstrateSharedMemory() throws IOException {
// 创建共享内存文件
Path shmFile = Paths.get("/dev/shm/shared_buffer.bin");

// 进程A：创建并写入
try (FileChannel channel = FileChannel.open(shmFile,
StandardOpenOption.CREATE,
StandardOpenOption.READ,
StandardOpenOption.WRITE)) {

MappedByteBuffer buffer = channel.map(
FileChannel.MapMode.READ_WRITE, 0, 1024);

buffer.putInt(0, 42); // 写入共享数据
buffer.putInt(4, 100);

System.out.println("进程A写入数据");
System.out.println("值1: " + buffer.getInt(0));
System.out.println("值2: " + buffer.getInt(4));
}

// 进程B：打开并读取（实际在另一个进程中）
try (FileChannel channel = FileChannel.open(shmFile,
StandardOpenOption.READ,
StandardOpenOption.WRITE)) {

MappedByteBuffer buffer = channel.map(
FileChannel.MapMode.READ_WRITE, 0, 1024);

System.out.println("\\n进程B读取数据");
System.out.println("值1: " + buffer.getInt(0));
System.out.println("值2: " + buffer.getInt(4));

// 进程B修改数据
buffer.putInt(0, 84);
System.out.println("进程B修改值1为: " + buffer.getInt(0));
}

// 验证进程A能看到修改（需要实际运行两个进程）
}
}
}
}

六、NIO 面试题深度解析

6.1 基础概念类面试题

Q1：请详细解释 NIO 的三大核心组件及其关系

标准答案结构：

public class NIOCoreComponents {
/**
* NIO 三大核心：Channel、Buffer、Selector
*
* 1. Channel（通道）：
* – 作用：数据的源头或目的地（文件、网络套接字等）
* – 特点：双向的，可以同时读写；非阻塞模式支持
* – 常见实现：FileChannel、SocketChannel、ServerSocketChannel、DatagramChannel
*
* 2. Buffer（缓冲区）：
* – 作用：数据的临时存储容器，Channel的所有操作都通过Buffer
* – 特点：有position、limit、capacity、mark四个状态变量
* – 类型：ByteBuffer、CharBuffer、IntBuffer等
*
* 3. Selector（选择器）：
* – 作用：单线程管理多个Channel，监控它们的事件
* – 工作原理：基于事件驱动，当Channel有事件就绪时通知应用
* – 事件类型：OP_READ、OP_WRITE、OP_CONNECT、OP_ACCEPT
*
* 三者关系：
* Channel ↔ Buffer：Channel读取数据到Buffer，或从Buffer写入数据到Channel
* Channel → Selector：Channel注册到Selector，Selector监控Channel事件
* 工作流程：应用通过Selector.select()获取就绪的Channel，然后通过Buffer与Channel交互
*/

// 工作流程示例
void workflowExample() throws IOException {
// 1. 创建Selector
Selector selector = Selector.open();

// 2. 创建Channel并配置为非阻塞
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false);
serverChannel.bind(new InetSocketAddress(8080));

// 3. Channel注册到Selector，关注ACCEPT事件
serverChannel.register(selector, SelectionKey.OP_ACCEPT);

// 4. 事件循环
while (true) {
selector.select(); // 阻塞等待事件

Set<SelectionKey> keys = selector.selectedKeys();
for (SelectionKey key : keys) {
if (key.isAcceptable()) {
// 5. 接受连接，创建新的Channel
SocketChannel clientChannel = serverChannel.accept();
clientChannel.configureBlocking(false);

// 6. 为新Channel创建Buffer
ByteBuffer buffer = ByteBuffer.allocate(1024);

// 7. 新Channel注册到Selector，关注READ事件
clientChannel.register(selector, SelectionKey.OP_READ, buffer);
} else if (key.isReadable()) {
// 8. 读取数据到Buffer
SocketChannel channel = (SocketChannel) key.channel();
ByteBuffer buffer = (ByteBuffer) key.attachment();

buffer.clear();
channel.read(buffer);

// 9. 处理Buffer中的数据
buffer.flip();
// … 处理逻辑
}
}
keys.clear();
}
}
}

Q2：ByteBuffer 有哪些重要的状态变量？它们如何工作？

深度解析：

public class ByteBufferState {
/**
* ByteBuffer 的四个核心状态变量：
*
* 1. capacity（容量）：
* – 含义：缓冲区的最大容量，创建时指定，不可改变
* – 示例：ByteBuffer.allocate(1024) → capacity=1024
*
* 2. position（位置）：
* – 含义：下一个要读或写的位置索引
* – 写模式：初始为0，每写入一个元素增加1
* – 读模式：初始为0，每读取一个元素增加1
*
* 3. limit（限制）：
* – 含义：第一个不能读或写的位置索引
* – 写模式：limit = capacity
* – 读模式：limit = 实际写入的数据量（通过flip()设置）
*
* 4. mark（标记）：
* – 含义：一个备忘位置，通过mark()设置，通过reset()恢复
* – 作用：临时标记一个位置，稍后可以回到这个位置
*
* 状态转换：
* 初始状态: position=0, limit=capacity, mark=-1
* 写入数据: position移动，limit不变
* flip(): position=0, limit=原position, mark=-1（切换到读模式）
* 读取数据: position移动，limit不变
* clear(): position=0, limit=capacity, mark=-1（切换到写模式，但不清数据）
* compact(): 将未读数据复制到缓冲区开头，position=剩余数据量，limit=capacity
* rewind(): position=0, limit不变, mark=-1（重新读）
*/

// 状态转换演示
void demonstrateStateTransitions() {
ByteBuffer buffer = ByteBuffer.allocate(10);
printState(buffer, "初始状态");

// 写入3个字节
buffer.put((byte) 1);
buffer.put((byte) 2);
buffer.put((byte) 3);
printState(buffer, "写入3字节后");

// flip切换到读模式
buffer.flip();
printState(buffer, "flip()后");

// 读取1个字节
buffer.get();
printState(buffer, "读取1字节后");

// mark当前位置
buffer.mark();
printState(buffer, "mark()后");

// 再读取1个字节
buffer.get();
printState(buffer, "再读取1字节后");

// reset回到mark位置
buffer.reset();
printState(buffer, "reset()后");

// rewind重新读
buffer.rewind();
printState(buffer, "rewind()后");

// clear（准备写，但不清除数据）
buffer.clear();
printState(buffer, "clear()后");

// 写入数据会覆盖原有数据
buffer.put((byte) 4);
printState(buffer, "覆盖写入后");
}

void printState(ByteBuffer buffer, String description) {
System.out.printf("%s: position=%d, limit=%d, capacity=%d%n",
description, buffer.position(), buffer.limit(), buffer.capacity());
}
}

6.2 设计与原理类面试题

Q3：请解释 Selector 的工作原理和底层实现

深度解析：

public class SelectorPrinciples {
/**
* Selector 工作原理：
*
* 1. 注册阶段：
* – Channel调用register()方法注册到Selector
* – Selector内部创建SelectionKey，包含Channel和感兴趣的事件
* – 底层：将文件描述符(fd)添加到epoll/kqueue/select的事件集合
*
* 2. 选择阶段：
* – 应用程序调用select()方法
* – 底层：调用操作系统I/O多路复用函数
* – Linux: epoll_wait()
* – BSD/Mac: kqueue()
* – Windows: select() 或 poll()
* – 操作系统检查哪些fd有事件就绪，返回就绪的fd列表
*
* 3. 处理阶段：
* – Selector将就绪的fd转换为SelectionKey，添加到selectedKeys集合
* – 应用程序遍历selectedKeys，处理就绪的事件
*
* 底层实现细节（以Linux epoll为例）：
*
* 1. epoll_create(): 创建epoll实例，返回文件描述符
* 2. epoll_ctl(): 添加/修改/删除要监控的fd
* 3. epoll_wait(): 等待事件发生，返回就绪的fd列表
*
* epoll的两种触发模式：
* – 水平触发（Level-Triggered, LT）：
* 只要缓冲区有数据，就会一直通知
* – 边缘触发（Edge-Triggered, ET）：
* 只有状态变化时才通知一次
*
* Java NIO默认使用水平触发
*/

// Selector 的性能考虑
class SelectorPerformance {
void performanceConsiderations() {
/* Selector 性能影响因素：
*
* 1. 就绪事件处理速度：
* – 快速处理selectedKeys，避免阻塞
* – 使用多Selector分担压力
*
* 2. 事件类型选择：
* – 只在需要时注册OP_WRITE事件
* – 避免频繁修改interestOps
*
* 3. 缓冲区管理：
* – 使用对象池复用ByteBuffer
* – 调整缓冲区大小匹配网络MTU
*
* 4. 线程模型：
* – 一个Selector一个线程（Reactor模式）
* – 主从Reactor模式：主Selector接受连接，从Selector处理IO
*
* 5. 避免空轮询bug（某些JDK版本）：
* – 设置合理的select超时时间
* – 监控select调用次数
*/
}
}

// 常见问题与解决方案
class SelectorIssues {
void commonIssuesAndSolutions() {
/* 问题1：Selector.select()空返回
* 原因：没有正确移除selectedKeys中的key
* 解决：处理完key后调用iterator.remove()
*
* 问题2：CPU 100%
* 原因：select()立即返回，造成忙等待
* 解决：检查是否有Channel不断触发事件，或JDK空轮询bug
*
* 问题3：内存泄漏
* 原因：Channel关闭后SelectionKey未取消
* 解决：确保Channel关闭时key被取消
*
* 问题4：事件丢失
* 原因：处理事件时发生了新的事件
* 解决：一次select()后处理所有就绪事件
*
* 问题5：并发修改异常
* 原因：多线程操作同一个Selector
* 解决：一个Selector只由一个线程操作
*/
}
}
}

Q4：直接缓冲区 vs 堆缓冲区，如何选择？

全面对比分析：

public class DirectVsHeapBufferComparison {
/**
* 直接缓冲区（Direct Buffer）与堆缓冲区（Heap Buffer）对比：
*
* | 维度 | 堆缓冲区 | 直接缓冲区 |
* |——|———|———–|
* | 内存位置 | JVM堆内 | 堆外内存 |
* | 分配成本 | 低 | 高（是堆缓冲区的2-3倍） |
* | 释放成本 | GC自动回收 | 手动管理或Cleaner |
* | I/O性能 | 需要一次拷贝 | 零拷贝（直接传输） |
* | 内存占用 | 受GC管理 | 不受GC管理，计入DirectMemory |
* | 适用场景 | 小数据、频繁创建销毁 | 大文件、频繁I/O、长期存在 |
* | 访问速度 | 快（CPU缓存友好） | 较慢（跨边界访问） |
* | 线程安全 | 不安全（需同步） | 不安全（需同步） |
*/

// 选择策略
class SelectionStrategy {
void chooseBufferType() {
/* 选择堆缓冲区的情况：
* 1. 缓冲区大小 < 1KB
* 2. 生命周期短，频繁创建销毁
* 3. 主要用于计算，较少I/O操作
* 4. 需要与大量Java对象交互
*
* 选择直接缓冲区的情况：
* 1. 缓冲区大小 > 64KB
* 2. 长期存在，需要复用
* 3. 频繁的I/O操作（网络、文件）
* 4. 需要与JNI/Native代码交互
* 5. 使用内存映射文件
*/
}
}

// 性能测试示例
class PerformanceBenchmark {
void benchmark() throws IOException {
int size = 1024 * 1024; // 1MB
int iterations = 1000;

// 测试1：分配性能
System.out.println("=== 分配性能测试 ===");

long heapAllocStart = System.nanoTime();
for (int i = 0; i < iterations; i++) {
ByteBuffer.allocate(size);
}
long heapAllocTime = System.nanoTime() – heapAllocStart;

long directAllocStart = System.nanoTime();
for (int i = 0; i < iterations; i++) {
ByteBuffer.allocateDirect(size);
}
long directAllocTime = System.nanoTime() – directAllocStart;

System.out.printf("堆缓冲区分配: %.2f ms%n",
heapAllocTime / 1_000_000.0);
System.out.printf("直接缓冲区分配: %.2f ms%n",
directAllocTime / 1_000_000.0);
System.out.printf("分配成本比: %.1f:1%n",
(double) directAllocTime / heapAllocTime);

// 测试2：I/O性能
System.out.println("\\n=== I/O性能测试 ===");

Path tempFile = Files.createTempFile("test", ".dat");
byte[] data = new byte[size];
new Random().nextBytes(data);
Files.write(tempFile, data);

// 堆缓冲区I/O
long heapIOStart = System.nanoTime();
try (FileChannel channel = FileChannel.open(tempFile,
StandardOpenOption.READ)) {
ByteBuffer heapBuffer = ByteBuffer.allocate(size);
for (int i = 0; i < iterations; i++) {
channel.read(heapBuffer);
heapBuffer.clear();
}
}
long heapIOTime = System.nanoTime() – heapIOStart;

// 直接缓冲区I/O
long directIOStart = System.nanoTime();
try (FileChannel channel = FileChannel.open(tempFile,
StandardOpenOption.READ)) {
ByteBuffer directBuffer = ByteBuffer.allocateDirect(size);
for (int i = 0; i < iterations; i++) {
channel.read(directBuffer);
directBuffer.clear();
}
}
long directIOTime = System.nanoTime() – directIOStart;

System.out.printf("堆缓冲区I/O: %.2f ms%n",
heapIOTime / 1_000_000.0);
System.out.printf("直接缓冲区I/O: %.2f ms%n",
directIOTime / 1_000_000.0);
System.out.printf("I/O性能提升: %.1f%%%n",
(heapIOTime – directIOTime) * 100.0 / heapIOTime);

// 清理
Files.deleteIfExists(tempFile);
}
}

// 内存管理最佳实践
class MemoryManagement {
void bestPractices() {
/* 直接缓冲区的内存管理：
*
* 1. 监控 DirectMemory 使用：
* – JVM参数：-XX:MaxDirectMemorySize
* – 通过BufferPoolMXBean监控
*
* 2. 避免内存泄漏：
* – 及时释放不再使用的直接缓冲区
* – 使用引用队列（ReferenceQueue）跟踪
* – 避免在循环中创建大量直接缓冲区
*
* 3. 缓冲区复用：
* – 使用对象池缓存直接缓冲区
* – 根据业务特点调整缓冲区大小
*
* 4. 优雅关闭：
* – 确保所有Channel和Buffer正确关闭
* – 在关闭前flush所有数据
*
* 5. 监控GC影响：
* – 直接缓冲区通过Cleaner释放，可能影响GC
* – 监控Full GC频率和持续时间
*/

// 监控示例
List<BufferPoolMXBean> pools = ManagementFactory
.getPlatformMXBeans(BufferPoolMXBean.class);

for (BufferPoolMXBean pool : pools) {
System.out.printf("缓冲区池: %s%n", pool.getName());
System.out.printf(" 总容量: %,d 字节%n", pool.getTotalCapacity());
System.out.printf(" 使用中: %,d 字节%n", pool.getMemoryUsed());
System.out.printf(" 数量: %,d%n", pool.getCount());
}
}
}
}

6.3 性能与优化类面试题

Q5：如何优化 NIO 应用的性能？

系统性优化方案：

public class NIOOptimization {

// 1. 缓冲区优化
class BufferOptimization {
void optimizeBuffers() {
/* 缓冲区优化策略：
*
* a) 大小选择：
* – 网络I/O：通常1KB-8KB，匹配MTU（1500字节）
* – 文件I/O：通常8KB-64KB，匹配磁盘块大小（4KB）
* – 测试不同大小：512B, 1KB, 2KB, 4KB, 8KB, 16KB
*
* b) 直接缓冲区使用：
* – 频繁I/O操作使用直接缓冲区
* – 实现缓冲区池，复用缓冲区
* – 避免频繁创建销毁
*
* c) 批量操作：
* – 使用聚集/分散I/O
* – 批量put/get操作
* – 使用transferTo/transferFrom
*/

// 缓冲区池实现
class BufferPool {
private final Queue<ByteBuffer> pool = new ConcurrentLinkedQueue<>();
private final int bufferSize;
private final boolean direct;

public ByteBuffer acquire() {
ByteBuffer buffer = pool.poll();
if (buffer == null) {
buffer = direct ?
ByteBuffer.allocateDirect(bufferSize) :
ByteBuffer.allocate(bufferSize);
}
buffer.clear();
return buffer;
}

public void release(ByteBuffer buffer) {
if (buffer != null && buffer.capacity() == bufferSize) {
buffer.clear();
pool.offer(buffer);
}
}
}
}
}

// 2. Selector 优化
class SelectorOptimization {
void optimizeSelectors() {
/* Selector 优化策略：
*
* a) 多Selector负载均衡：
* – 根据CPU核心数创建多个Selector
* – 使用轮询或Hash分配连接
*
* b) 事件处理优化：
* – 快速处理selectedKeys，避免阻塞
* – 将耗时操作移到其他线程
* – 使用线程池处理业务逻辑
*
* c) 避免空轮询：
* – 设置合理的select超时时间
* – 监控select调用频率
* – 升级JDK修复已知bug
*
* d) 连接管理：
* – 及时关闭空闲连接
* – 实现连接超时机制
* – 限制最大连接数
*/

// 多Selector实现
class MultiSelector {
private final Selector[] selectors;
private final AtomicInteger counter = new AtomicInteger(0);

public MultiSelector(int count) throws IOException {
selectors = new Selector[count];
for (int i = 0; i < count; i++) {
selectors[i] = Selector.open();

// 每个Selector一个线程
Thread thread = new Thread(() -> runSelector(selectors[i]));
thread.setDaemon(true);
thread.start();
}
}

public Selector selectSelector(SocketChannel channel) {
// 简单轮询分配
int index = Math.abs(channel.hashCode()) % selectors.length;
return selectors[index];
}

private void runSelector(Selector selector) {
try {
while (!Thread.interrupted()) {
selector.select(1000); // 1秒超时

Set<SelectionKey> keys = selector.selectedKeys();
for (SelectionKey key : keys) {
// 处理事件…
}
keys.clear();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}

// 3. 线程模型优化
class ThreadModelOptimization {
void optimizeThreadModel() {
/* 线程模型选择：
*
* a) Reactor 模式：
* – 单Reactor单线程：简单，但CPU成为瓶颈
* – 单Reactor多线程：I/O单线程，业务多线程
* – 主从Reactor多线程：主Reactor接受连接，从Reactor处理I/O
*
* b) Proactor 模式：
* – 异步I/O，由操作系统完成I/O操作
* – 应用只处理完成事件
* – Java AIO (AsynchronousChannel) 实现
*
* c) 工作线程池：
* – I/O线程只负责读写
* – 业务逻辑交给线程池
* – 避免阻塞I/O线程
*/

// 主从Reactor实现示例
class MasterSlaveReactor {
private Selector masterSelector; // 接受连接
private Selector[] slaveSelectors; // 处理I/O
private ExecutorService workerPool; // 业务线程池

public void start() throws IOException {
masterSelector = Selector.open();
slaveSelectors = new Selector[Runtime.getRuntime().availableProcessors()];

for (int i = 0; i < slaveSelectors.length; i++) {
slaveSelectors[i] = Selector.open();
// 启动slave线程
new Thread(new SlaveReactor(slaveSelectors[i])).start();
}

workerPool = Executors.newFixedThreadPool(
Runtime.getRuntime().availableProcessors() * 2);

// 启动master线程
new Thread(new MasterReactor()).start();
}

class MasterReactor implements Runnable {
public void run() {
try {
while (!Thread.interrupted()) {
masterSelector.select();

Set<SelectionKey> keys = masterSelector.selectedKeys();
for (SelectionKey key : keys) {
if (key.isAcceptable()) {
// 接受连接，分配给slave Selector
SocketChannel client = ((ServerSocketChannel) key.channel()).accept();
client.configureBlocking(false);

// 轮询选择slave Selector
Selector slaveSelector = slaveSelectors[
counter.getAndIncrement() % slaveSelectors.length];

// 注册到slave Selector需要同步
synchronized (slaveSelector) {
slaveSelector.wakeup();
client.register(slaveSelector, SelectionKey.OP_READ);
}
}
}
keys.clear();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

class SlaveReactor implements Runnable {
private final Selector selector;

public SlaveReactor(Selector selector) {
this.selector = selector;
}

public void run() {
try {
while (!Thread.interrupted()) {
selector.select();

Set<SelectionKey> keys = selector.selectedKeys();
for (SelectionKey key : keys) {
if (key.isReadable()) {
// 读取数据
SocketChannel channel = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer);

// 提交给工作线程处理
workerPool.submit(() -> {
processRequest(buffer, channel);
});
}
}
keys.clear();
}
} catch (IOException e) {
e.printStackTrace();
}
}

private void processRequest(ByteBuffer buffer, SocketChannel channel) {
// 业务逻辑处理
buffer.flip();
// … 处理请求

// 响应客户端
ByteBuffer response = ByteBuffer.wrap("OK".getBytes());
try {
channel.write(response);
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
}

// 4. 内存映射优化
class MemoryMappingOptimization {
void optimizeMemoryMapping() {
/* 内存映射优化策略：
*
* a) 映射大小：
* – 不要映射整个大文件（可能耗尽虚拟内存）
* – 分块映射，滑动窗口方式
* – 映射大小 = 2^n 字节，对齐页面大小（通常4KB）
*
* b) 访问模式：
* – 顺序访问比随机访问快得多
* – 使用预读（prefetch）优化顺序访问
* – 避免频繁的小数据访问
*
* c) 同步策略：
* – 根据需求选择force()调用频率
* – 异步写入，批量同步
* – 使用Write-Behind策略
*/

// 滑动窗口内存映射
class SlidingWindowMappedFile {
private final FileChannel channel;
private final long fileSize;
private final int windowSize;

private MappedByteBuffer currentWindow;
private long currentOffset;

public SlidingWindowMappedFile(String filename, int windowSize)
throws IOException {
this.channel = FileChannel.open(Paths.get(filename),
StandardOpenOption.READ);
this.fileSize = channel.size();
this.windowSize = windowSize;
this.currentOffset = 0;

mapWindow(0);
}

private void mapWindow(long offset) throws IOException {
if (currentWindow != null) {
currentWindow.force();
}