// 不加缓冲：每次 read() 都可能触发一次系统调用
try (InputStream in = new FileInputStream("big.txt")) {
    int b;
    while ((b = in.read()) != -1) { /* 逐字节读，慢 */ }
}

// 加缓冲：一次性读 8KB 到内存，后续命中缓冲区
try (BufferedReader br = new BufferedReader(
        new InputStreamReader(new FileInputStream("big.txt"), StandardCharsets.UTF_8))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
}

ServerSocket serverSocket = new ServerSocket(8080);
while (true) {
    Socket socket = serverSocket.accept();      // 阻塞，直到有连接
    new Thread(() -> handle(socket)).start();   // 一连接一线程
}

ByteBuffer buf = ByteBuffer.allocate(1024);
buf.put("hello".getBytes());   // 写模式：position=5, limit=1024
buf.flip();                    // 切换到读模式：limit=5, position=0
while (buf.hasRemaining()) {
    System.out.print((char) buf.get());
}
buf.clear();                   // 清空，回到写模式：position=0, limit=capacity

try (FileChannel in = FileChannel.open(Paths.get("a.dat"), StandardOpenOption.READ);
     FileChannel out = FileChannel.open(Paths.get("b.dat"),
             StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
    long size = in.size();
    long pos = 0;
    while (pos < size) {
        pos += in.transferTo(pos, size - pos, out);   // 零拷贝搬运
    }
}

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

ByteBuffer buf = ByteBuffer.allocate(1024);
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();
            buf.clear();
            int n = sc.read(buf);
            if (n == -1) { sc.close(); continue; }
            buf.flip();
            sc.write(buf);                    // Echo 回去
        }
    }
}

// 风格一：Future —— 主动轮询结果
AsynchronousSocketChannel ch = AsynchronousSocketChannel.open();
Future<Integer> f = ch.read(ByteBuffer.allocate(1024));
int n = f.get();   // 阻塞在这里取结果

// 风格二：CompletionHandler —— 回调，真正的异步
ch.read(buffer, null, new CompletionHandler<Integer, Void>() {
    @Override
    public void completed(Integer result, Void attachment) {
        buffer.flip();
        // 处理数据……
    }
    @Override
    public void failed(Throwable exc, Void attachment) {
        exc.printStackTrace();
    }
});

// FileChannel.transferTo 底层即 sendfile（Linux 上还可用 sendfile + DMA gather 进一步优化）
in.transferTo(position, count, out);