Java 中的NIO、BIO和AIO详细总结

在Java中，处理输入输出（I/O）操作的方式主要有三种：传统的阻塞I/O（BIO）、非阻塞I/O（NIO）以及异步I/O（AIO）。这三者各有优缺点，适用于不同的场景，本文将详细总结这三种I/O方式，并给出相关的代码示例。

一、BIO（Blocking I/O）

BIO是Java早期的I/O处理方式，采用的是阻塞模式。每当有一个请求到来时，都会创建一个新的线程来处理这个请求，处理完成后，该线程便会结束。由于线程的创建和销毁都需要耗费资源，因此在高并发情况下，BIO并不高效。

优点： - 实现简单，易于理解和使用。 - 适用于并发量较低的场景。

缺点： - 每个连接都需要开辟一个线程，线程数量会随着请求数量的增加而增加，容易导致资源耗尽。 - 不适合处理高并发。

示例代码：

import java.io.*;
import java.net.*;

public class BioServer {
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(8888)) {
            while (true) {
                Socket socket = serverSocket.accept();
                new Thread(new ClientHandler(socket)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    static class ClientHandler implements Runnable {
        private Socket socket;

        public ClientHandler(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            try (BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                 PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {
                String inputLine;
                while ((inputLine = in.readLine()) != null) {
                    System.out.println("Received: " + inputLine);
                    out.println("Echo: " + inputLine);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

二、NIO（Non-blocking I/O）

NIO是从JDK 1.4开始引入的，提供了一种基于通道（Channel）和缓冲区（Buffer）机制的I/O操作。NIO支持非阻塞模式，允许单线程处理多个请求，这在处理高并发场景下非常高效。

优点： - 非阻塞模式，能够更高效地处理大量连接。 - 使用选择器（Selector）可以让单个线程管理多个通道，降低线程资源的消耗。

缺点： - 相对BIO，学习曲线较陡峭，实现复杂度较高。

示例代码：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.Selector;
import java.nio.channels.SelectionKey;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class NioServer {
    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.bind(new InetSocketAddress(8888));
        serverSocket.configureBlocking(false);
        serverSocket.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {
            selector.select();
            Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
            while (keys.hasNext()) {
                SelectionKey key = keys.next();
                keys.remove();

                if (key.isAcceptable()) {
                    SocketChannel client = serverSocket.accept();
                    client.configureBlocking(false);
                    client.register(selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) {
                    SocketChannel client = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(256);
                    int bytesRead = client.read(buffer);
                    if (bytesRead == -1) {
                        client.close();
                    } else {
                        buffer.flip();
                        client.write(buffer);
                    }
                }
            }
        }
    }
}

三、AIO（Asynchronous I/O）

AIO是Java 7引入的特性，采用完全异步的方式来处理I/O操作。它允许应用程序继续执行其他操作而不需要等待I/O操作完成。AIO通过回调机制通知应用程序I/O操作的完成。

优点： - 可以处理大量的并发连接，资源占用低。 - 非常适合于I/O密集型应用。

缺点： - 实现相对复杂，调试和管理异步回调可能比较麻烦。 - 不适合对响应时间要求很高的场景。

示例代码：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.ByteBuffer;
import java.nio.channels.CompletionHandler;

public class AioServer {
    public static void main(String[] args) throws IOException {
        AsynchronousServerSocketChannel serverSocketChannel = AsynchronousServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(8888));

        serverSocketChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
            @Override
            public void completed(AsynchronousSocketChannel channel, Void attachment) {
                // 继续接受新的连接
                serverSocketChannel.accept(null, this);

                // 处理连接
                ByteBuffer buffer = ByteBuffer.allocate(256);
                channel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                    @Override
                    public void completed(Integer result, ByteBuffer attachment) {
                        attachment.flip();
                        channel.write(attachment);
                    }

                    @Override
                    public void failed(Throwable exc, ByteBuffer attachment) {
                        try {
                            channel.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }

            @Override
            public void failed(Throwable exc, Void attachment) {
                exc.printStackTrace();
            }
        });

        // 防止主线程结束
        try {
            Thread.sleep(Long.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

总结

BIO、NIO和AIO各有不同的适用场景和特点。BIO适合简单、低并发的应用；NIO适合于高并发的应用，需要合理管理系统资源；AIO则适合I/O密集型的场景，可以最大化资源利用效率。根据具体的业务需求选择合适的I/O方案，可以有效提高应用的性能和响应能力。