常见IO模型总结 BIO NIO AIO

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;

/**
 * NIO 服务端：同步非阻塞 + 多路复用（Selector）
 * 核心：一个 Selector 线程管理多个 Channel
 */
public class NioServer {
    
    public static void main(String[] args) throws IOException {
        // 1. 创建 Selector（多路复用器）
        Selector selector = Selector.open();
        
        // 2. 创建 ServerSocketChannel，绑定端口
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.bind(new InetSocketAddress(8080));
        serverChannel.configureBlocking(false);  // 关键：设置为非阻塞模式
        
        // 3. 注册到 Selector，监听 ACCEPT 事件
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("NIO Server started on 8080");
        
        while (true) {
            // 4. 阻塞等待就绪事件（有事件才唤醒，否则休眠）
            selector.select();
            
            // 5. 获取就绪的 SelectionKey 集合
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectedKeys.iterator();
            
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove();  // 必须移除，否则重复处理
                
                if (key.isAcceptable()) {
                    // 有新连接接入
                    handleAccept(key, selector);
                } else if (key.isReadable()) {
                    // 有数据可读
                    handleRead(key);
                } else if (key.isWritable()) {
                    // 可以写数据
                    handleWrite(key);
                }
            }
        }
    }
    
    // 处理连接请求
    private static void handleAccept(SelectionKey key, Selector selector) 
            throws IOException {
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
        SocketChannel clientChannel = serverChannel.accept();  // 非阻塞，立即返回
        clientChannel.configureBlocking(false);
        
        // 注册读事件，并附带一个 Buffer
        clientChannel.register(selector, SelectionKey.OP_READ, 
            ByteBuffer.allocate(1024));
        
        System.out.println("Client connected: " + clientChannel.getRemoteAddress());
    }
    
    // 处理读事件
    private static void handleRead(SelectionKey key) throws IOException {
        SocketChannel channel = (SocketChannel) key.channel();
        ByteBuffer buffer = (ByteBuffer) key.attachment();
        
        int read = channel.read(buffer);  // 非阻塞读取
        if (read == -1) {
            // 客户端断开
            key.cancel();
            channel.close();
            return;
        }
        
        buffer.flip();
        byte[] data = new byte[buffer.remaining()];
        buffer.get(data);
        String message = new String(data);
        System.out.println("Received: " + message);
        
        // 准备写回响应
        buffer.clear();
        buffer.put(("Echo: " + message).getBytes());
        buffer.flip();
        
        // 切换为写模式
        key.interestOps(SelectionKey.OP_WRITE);
    }
    
    // 处理写事件
    private static void handleWrite(SelectionKey key) throws IOException {
        SocketChannel channel = (SocketChannel) key.channel();
        ByteBuffer buffer = (ByteBuffer) key.attachment();
        
        channel.write(buffer);  // 非阻塞写入
        
        if (!buffer.hasRemaining()) {
            // 写完了，切回读模式
            buffer.clear();
            key.interestOps(SelectionKey.OP_READ);
        }
    }
}