Java BIO 和 NIO 使用，有什么区别

Java 中的 I/O 操作主要有两种方式：BIO 和 NIO。BIO（Blocking I/O）是同步阻塞 I/O 模型，而 NIO（Non-Blocking I/O）是异步非阻塞 I/O 模型。这两种 I/O 模型在编写网络应用程序时有着不同的优缺点，下面我们将会详细讨论它们的区别。

区别和模型

Java BIO：同步并阻塞（传统阻塞型），服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不作任何事情会造成不必要的线程开销。

Java NIO：同步非阻塞，服务器实现模式为一个线程处理多个请求(连接)，即客户端发送的连接请求会被注册到多路复用器上，多路复用器轮询到有 I/O 请求就会进行处理。

BIO

BIO 是 Java 最早的 I/O 模型，它是阻塞式的 I/O 模型，即在进行读写操作时，当前线程会一直阻塞，直到读写完成。BIO 通常是单线程的，也就是说一个连接需要一个线程来处理，如果连接数量很大，那么就需要创建很多线程，这样会导致系统的资源消耗过大。

下面是一个简单的 BIO 服务端代码：

public class Server {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream inputStream = null;
        try {
            serverSocket = new ServerSocket(8888);
            System.out.println("服务端启动，等待客户端连接...");
            while (true) {
                socket = serverSocket.accept();
                System.out.println("客户端连接成功：" + socket.getRemoteSocketAddress());
                inputStream = socket.getInputStream();
                byte[] buffer = new byte[1024];
                int len;
                while ((len = inputStream.read(buffer)) != -1) {
                    System.out.println("接收到客户端消息：" + new String(buffer, 0, len));
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (inputStream != null) {
                    inputStream.close();
                }
                if (socket != null) {
                    socket.close();
                }
                if (serverSocket != null) {
                    serverSocket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

这段代码中，我们启动了一个服务端，用于监听端口 8888，当有客户端连接时，就会创建一个新的线程处理该连接。在读取客户端发送的消息时，服务端会一直阻塞，直到读取完成，因此如果有多个连接同时发送消息，就需要创建多个线程来处理。

NIO

NIO 是 Java 1.4 引入的一种 I/O 模型，它是异步非阻塞的 I/O 模型，与 BIO 不同的是，NIO 的读写操作是非阻塞的，即读写操作不会一直阻塞当前线程，而是会立即返回，如果当前没有数据可读，或者写入的数据还没有完全被发送，就会返回 0 或者非阻塞状态，这样可以让当前线程继续执行其他任务，从而提高系统的并发能力。

下面是一个简单的 NIO 服务端代码：

public class Server {
    public static void main(String[] args) {
        ServerSocketChannel serverSocketChannel = null;
        Selector selector = null;
        try {
            serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.socket().bind(new InetSocketAddress(8888));
            serverSocketChannel.configureBlocking(false);
            selector = Selector.open();
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("服务端启动，等待客户端连接...");
            while (true) {
                int readyChannels = selector.select();
                if (readyChannels == 0) {
                    continue;
                }
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey selectionKey = iterator.next();
                    iterator.remove();
                    if (selectionKey.isAcceptable()) {
                        ServerSocketChannel server = (ServerSocketChannel) selectionKey.channel();
                        SocketChannel socketChannel = server.accept();
                        socketChannel.configureBlocking(false);
                        socketChannel.register(selector, SelectionKey.OP_READ);
                        System.out.println("客户端连接成功：" + socketChannel.getRemoteAddress());
                    } else if (selectionKey.isReadable()) {
                        SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        int len;
                        while ((len = socketChannel.read(buffer)) > 0) {
                            buffer.flip();
                            System.out.println("接收到客户端消息：" + new String(buffer.array(), 0, len));
                            buffer.clear();
                        }
                        if (len == -1) {
                            socketChannel.close();
                        }
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (serverSocketChannel != null) {
                    serverSocketChannel.close();
                }
                if (selector != null) {
                    selector.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

这段代码中，我们启动了一个 NIO 服务端，用于监听端口 8888，当有客户端连接时，就会注册一个读事件，并将其加入到选择器中。在读取客户端发送的消息时，服务端会一直读取，直到读取完成，但并不会阻塞当前线程，因此可以处理多个连接同时发送的消息。

区别

BIO 和 NIO 之间的最大区别在于阻塞和非阻塞。BIO 是阻塞式的 I/O 模型，而 NIO 是非阻塞式的 I/O 模型。BIO 通常是单线程的，一个连接需要一个线程来处理，如果连接数量很大，那么就需要创建很多线程，这样会导致系统的资源消耗过大。而 NIO 利用了选择器的概念，可以使用一个线程处理多个连接，从而提高系统的并发能力。

另外，NIO 还引入了缓冲区（Buffer）的概念，可以提高读写操作的效率。在 NIO 中，读取数据时先将数据读入到缓冲区中，然后再从缓冲区中读取数据。在写入数据时也是先将数据写入到缓冲区中，然后再从缓冲区中写出数据。

总结

BIO 和 NIO 之间的最大区别在于阻塞和非阻塞。BIO 是阻塞式的 I/O 模型，而 NIO 是非阻塞式的 I/O 模型。BIO 通常是单线程的，一个连接需要一个线程来处理，如果连接数量很大，那么就需要创建很多线程，这样会导致系统的资源消耗过大。而 NIO 利用了选择器的概念，可以使用一个线程处理多个连接，从而提高系统的并发能力。另外，NIO 还引入了缓冲区（Buffer）的概念，可以提高读写操作的效率。在使用 I/O 操作时，我们需要根据具体的业务需求选择合适的 I/O 模型，从而提高系统的性能和并发能力。