NIO 核心组件

┌─────────────────────────────────────────────────┐
│                  NIO 架构                        │
├─────────────────────────────────────────────────┤
│                                                 │
│    ┌──────────┐    读/写    ┌──────────┐        │
│    │ Channel  │ ←────────→ │  Buffer  │        │
│    │  (通道)   │            │  (缓冲区) │        │
│    └────┬─────┘            └──────────┘        │
│         │                                      │
│         │ 注册事件                              │
│         ↓                                      │
│    ┌──────────┐                                │
│    │ Selector │                                │
│    │(多路复用器)│                                │
│    └──────────┘                                │
│                                                 │
└─────────────────────────────────────────────────┘

// FileChannel 读写文件
RandomAccessFile file = new RandomAccessFile("data.txt", "rw");
FileChannel channel = file.getChannel();
 
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = channel.read(buffer);  // 读入 buffer
 
buffer.flip();  // 切换为读模式
while (buffer.hasRemaining()) {
    channel.write(buffer);  // 从 buffer 写出
}
 
channel.close();
 
// SocketChannel 客户端
SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);  // 非阻塞模式
socketChannel.connect(new InetSocketAddress("localhost", 8080));
 
while (!socketChannel.finishConnect()) {
    // 等待连接完成
}

┌─────────────────────────────────────────────────┐
│                 Buffer 结构                      │
├─────────────────────────────────────────────────┤
│                                                 │
│  0    1    2    3    4    5    6    7          │
│  ┌────┬────┬────┬────┬────┬────┬────┬────┐     │
│  │    │    │ ✓  │ ✓  │ ✓  │ ✓  │    │    │     │
│  └────┴────┴────┴────┴────┴────┴────┴────┘     │
│         ↑                        ↑              │
│       position                 limit            │
│                                                 │
│  capacity = 8 (总容量)                          │
│  position = 2 (下一个操作位置)                   │
│  limit = 6 (可操作边界)                          │
└─────────────────────────────────────────────────┘

写模式：position 从 0 开始增长，limit = capacity
    ↓ flip()
读模式：position = 0，limit = 原来的 position
    ↓ clear() / compact()
重置：恢复写模式

ByteBuffer buffer = ByteBuffer.allocate(1024);  // 分配空间
 
// 写入数据
buffer.put((byte) 'H');
buffer.put((byte) 'e');
buffer.put((byte) 'l');
buffer.put((byte) 'l');
buffer.put((byte) 'o');
 
// 切换为读模式
buffer.flip();
 
// 读取数据
while (buffer.hasRemaining()) {
    byte b = buffer.get();
    System.out.print((char) b);
}
 
// 清空，准备下次写入
buffer.clear();

// 创建 Selector
Selector selector = Selector.open();
 
// 创建 ServerSocketChannel 并配置
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.configureBlocking(false);
 
// 注册到 Selector，监听 ACCEPT 事件
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
 
// 事件循环
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 client = server.accept();
            client.configureBlocking(false);
            client.register(selector, SelectionKey.OP_READ);
        }
        
        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();
                // 处理数据
            }
        }
        
        keyIterator.remove();  // 移除已处理的事件
    }
}

堆内存 IO：
  JVM 堆 → 复制 → 直接内存 → 内核空间 → 磁盘

直接内存 IO：
  直接内存 → 内核空间 → 磁盘（少一次复制）