Java 网络编程与 NIO 实战

BIO 的痛点：
  每个 Socket 占一个线程，阻塞在 read 上。
  1000 连接 = 1000 线程，上下文切换开销巨大。
  解决方向：让一个线程同时"看管"多个连接的 IO 事件 —— 这就是 NIO。

NIO 三件套：
  Channel（通道）     —— 连接的抽象，读写都通过 Channel
  Buffer（缓冲区）    —— 数据存的中转站（ByteBuffer 等）
  Selector（选择器）  —— 一个线程注册多个 Channel，轮询"谁就绪了"

// 服务端：每来一个连接起一个线程（示意，勿直接用于生产）
try (ServerSocket server = new ServerSocket(8080)) {
    while (true) {
        Socket socket = server.accept();      // 阻塞等待连接
        new Thread(() -> handle(socket)).start(); // 每个连接一个线程
    }
}

// 客户端：SocketChannel 连接
SocketChannel channel = SocketChannel.open(new InetSocketAddress("localhost", 8080));
ByteBuffer buf = ByteBuffer.allocate(1024);
buf.put("GET / HTTP/1.1\r\nHost: localhost\r\n\r\n".getBytes());

buf.flip();              // 写模式 → 读模式（position=0, limit=写到的位置）
channel.write(buf);      // 把 buffer 内容发给服务器

buf.clear();             // 回到写模式
int n = channel.read(buf);  // 读取响应
buf.flip();
System.out.println(new String(buf.array(), 0, buf.limit()));

position：下一个读写的位置
limit：  可读/可写的上限
capacity：缓冲区容量
mark：   标记，可 reset 回退

常用切换：
  flip()  ：写→读（limit=position, position=0）
  clear() ：读→写（position=0, limit=capacity）
  compact()：读→写并保留未读完数据

Selector selector = Selector.open();
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.configureBlocking(false);              // 必须非阻塞才能注册
ssc.bind(new InetSocketAddress(8080));
ssc.register(selector, SelectionKey.OP_ACCEPT);

while (true) {
    selector.select();                     // 阻塞等待任一注册通道就绪
    Iterator<SelectionKey> it = selector.selectedKeys().iterator();
    while (it.hasNext()) {
        SelectionKey key = it.next();
        it.remove();                       // 必须手动移除
        if (key.isAcceptable()) {
            SocketChannel sc = ssc.accept();
            sc.configureBlocking(false);
            sc.register(selector, SelectionKey.OP_READ);  // 注册读事件
        } else if (key.isReadable()) {
            SocketChannel sc = (SocketChannel) key.channel();
            ByteBuffer buf = ByteBuffer.allocate(1024);
            sc.read(buf);
        }
    }
}

传统 IO 四次拷贝 + 四次上下文切换：
  磁盘 → 内核缓冲 → 用户缓冲 → 内核 socket 缓冲 → 网卡

零拷贝（transferTo）：
  磁盘 → 内核缓冲 → 网卡   （sendfile 由内核直接搬运，减少用户态拷贝）

// FileChannel.transferTo 实现零拷贝发送文件
FileChannel file = FileChannel.open(Paths.get("big.bin"));
SocketChannel socket = ...;
long pos = 0;
long len = file.size();
while (pos < len) {
    pos += file.transferTo(pos, len - pos, socket);  // 内核态直接搬
}

ByteBuffer heap = ByteBuffer.allocate(1024);   // 堆内：有 GC，拷贝到内核要经堆外中转
ByteBuffer direct = ByteBuffer.allocateDirect(1024); // 堆外：免中转，但需手动释放

// 异步 GET 请求
HttpClient client = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(3))
        .version(HttpClient.Version.HTTP_2)
        .build();

CompletableFuture<HttpResponse<String>> future = client
        .sendAsync(
            HttpRequest.newBuilder(URI.create("https://api.example.com/users"))
                    .GET().build(),
            HttpResponse.BodyHandlers.ofString());

future.thenAccept(resp -> System.out.println(resp.statusCode() + resp.body()));

// 同步调用
HttpResponse<String> resp = client.send(
        HttpRequest.newBuilder(URI.create("https://example.com")).GET().build(),
        HttpResponse.BodyHandlers.ofString());

一句话：
  连接少 → BIO/虚拟线程都行
  连接多且每条连接活跃 → NIO 多路复用
  连接多但大多空闲/慢 IO → AIO 或异步回调最划算