【小喜AI助手·技术干货】2026年Java IO从BIO到AIO，一文讲透演进之路

// 传统BIO文件复制（逐个字节读取，极其低效）
public static void copyByByte(File src, File dest) throws IOException {
    try (InputStream in = new FileInputStream(src);
         OutputStream out = new FileOutputStream(dest)) {
        int b;
        while ((b = in.read()) != -1) {  // 每读一个字节，阻塞一次
            out.write(b);                // 每写一个字节，阻塞一次
        }
    }
}

// BIO服务端（线程池优化版）
import java.io.;
import java.net.;
import java.util.concurrent.;

public class BioServer {
    private static final int PORT = 8080;
    private static final int THREAD_POOL_SIZE = 50;

    public static void main(String[] args) throws IOException {
        // 创建固定大小的线程池，避免无限创建线程
        ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
        ServerSocket serverSocket = new ServerSocket(PORT);
        System.out.println("BIO服务端启动，等待客户端连接...");

        while (true) {
            // ⭐ 阻塞点1：accept()会阻塞，直到有客户端连接
            Socket clientSocket = serverSocket.accept();
            System.out.println("客户端连接成功：" + clientSocket.getInetAddress());

            // 提交到线程池处理
            threadPool.execute(() -> {
                try (InputStream input = clientSocket.getInputStream();
                     BufferedReader reader = new BufferedReader(
                         new InputStreamReader(input))) {
                    String line;
                    // ⭐ 阻塞点2：readLine()会阻塞，直到读到完整一行
                    while ((line = reader.readLine()) != null) {
                        System.out.println("收到消息：" + line);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    try { clientSocket.close(); } catch (IOException ignored) {}
                }
            });
        }
    }
}

// NIO服务端（Selector多路复用）
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.;
import java.util.Iterator;
import java.util.Set;

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. 将Channel注册到Selector，监听连接事件
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("NIO服务端启动，监听端口8080...");

        // 4. 事件循环
        while (true) {
            // ⭐ 阻塞点：selector.select()阻塞，直到有事件发生
            int readyCount = selector.select();
            if (readyCount == 0) continue;

            // 获取所有就绪的事件集合
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> iter = selectedKeys.iterator();

            while (iter.hasNext()) {
                SelectionKey key = iter.next();
                iter.remove();  // 处理完的事件必须移除

                // 处理连接事件
                if (key.isAcceptable()) {
                    ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                    SocketChannel clientChannel = channel.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 len = clientChannel.read(buffer);
                    if (len > 0) {
                        buffer.flip();  // ⭐ 切换为读模式
                        byte[] data = new byte[buffer.remaining()];
                        buffer.get(data);
                        System.out.println("收到消息：" + new String(data));
                    } else if (len == -1) {
                        clientChannel.close();  // 客户端断开连接
                    }
                }
            }
        }
    }
}

// AIO服务端（异步回调方式）
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;

public class AioServer {
    public static void main(String[] args) throws IOException, InterruptedException {
        // 创建异步ServerSocketChannel
        AsynchronousServerSocketChannel serverChannel = 
            AsynchronousServerSocketChannel.open();
        serverChannel.bind(new InetSocketAddress(8080));
        System.out.println("AIO服务端启动，监听端口8080...");

        // 异步接收连接，通过CompletionHandler回调
        serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
            @Override
            public void completed(AsynchronousSocketChannel clientChannel, Void attachment) {
                // 继续接收下一个连接（重要！）
                serverChannel.accept(null, this);
                
                // 准备缓冲区，异步读取数据
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                clientChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                    @Override
                    public void completed(Integer result, ByteBuffer attachment) {
                        attachment.flip();
                        byte[] data = new byte[attachment.remaining()];
                        attachment.get(data);
                        System.out.println("收到消息：" + new String(data));
                        try { clientChannel.close(); } catch (IOException e) {}
                    }
                    
                    @Override
                    public void failed(Throwable exc, ByteBuffer attachment) {
                        System.out.println("读取失败：" + exc.getMessage());
                    }
                });
            }
            
            @Override
            public void failed(Throwable exc, Void attachment) {
                System.out.println("连接失败：" + exc.getMessage());
            }
        });
        
        // 主线程保持运行
        Thread.currentThread().join();
    }
}

// 内存映射文件示例（适合大文件处理）
try (RandomAccessFile file = new RandomAccessFile("largefile.dat", "rw")) {
    FileChannel channel = file.getChannel();
    // 将文件前10MB映射到内存
    MappedByteBuffer buffer = channel.map(
        FileChannel.MapMode.READ_WRITE, 0, 10  1024  1024);
    
    // 像操作普通byte数组一样操作文件
    buffer.put(0, (byte) 'A');  // 直接修改文件第一个字节
}