《面试1v1》JavaNIO

我是 javapub，一名 Markdown 程序员从👨‍💻，八股文种子选手。

面试官：你好，我想问一下你对 Java NIO 的了解。

候选人： 当然，Java NIO 是 Java 的一种 I/O 模型，它提供了一种基于缓冲区和通道的 I/O 操作方式。相比传统的 I/O 模型，Java NIO 具有更高的性能和更好的扩展性。

面试官：那你能具体说一下 Java NIO 的特点吗？

候选人： 当然可以。Java NIO 的特点主要有以下几点：

非阻塞式 I/O：Java NIO 支持非阻塞式 I/O 操作，可以在等待 I/O 操作完成的同时，继续执行其他任务，从而提高系统的并发性能。
缓冲区：Java NIO 使用缓冲区来处理数据，可以提高数据的读写效率，并且可以支持随机访问。
通道：Java NIO 使用通道来进行数据的读写操作，通道可以支持双向数据传输，并且可以在不同的线程之间共享。
选择器：Java NIO 提供了选择器来实现多路复用，可以同时监控多个通道的 I/O 事件，从而提高系统的并发性能。

面试官：那你能说一下 Java NIO 的应用场景吗？

候选人： 当然可以。Java NIO 的应用场景非常广泛，包括网络编程、文件操作、内存映射等。例如，在网络编程中，Java NIO 可以实现高性能的服务器和客户端，可以支持大量的并发连接，并且可以使用选择器来实现多路复用。在文件操作中，Java NIO 可以实现高效的文件读写操作，可以使用内存映射来提高文件的读取速度。在内存映射中，Java NIO 可以将文件映射到内存中，从而可以直接访问文件的内容，而无需进行繁琐的读写操作。

面试官：那你能说一下 Java NIO 的核心组件吗？

候选人： 当然可以。Java NIO 的核心组件包括缓冲区（Buffer）、通道（Channel）、选择器（Selector）和字节编解码器（Charset）。缓冲区用于存储数据，通道用于进行数据的读写操作，选择器用于实现多路复用，字节编解码器用于将字节流转换为字符流。这些组件共同构成了 Java NIO 的基础架构，可以支持高效的 I/O 操作。

面试官：那你能给我举个例子，说明 Java NIO 在实际开发中的应用吗？

候选人： 当然可以。在一个聊天室应用中，可以使用 Java NIO 来实现多个客户端之间的通信。每个客户端都可以使用一个通道来进行数据的读写操作，而服务器可以使用一个选择器来监控所有的通道，从而实现多路复用。这样可以大大提高服务器的并发性能，支持大量的并发连接。

以下是一个简单的示例代码，用于实现一个简单的聊天室应用：

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

public class ChatRoomServer {
    private static final int PORT = 8888;
    private static final int BUFFER_SIZE = 1024;
    private static final String CHARSET = "UTF-8";

    public static void main(String[] args) throws IOException {
        // 创建一个选择器
        Selector selector = Selector.open();

        // 创建一个服务器通道，并绑定到指定的端口
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.socket().bind(new InetSocketAddress(PORT));
        serverChannel.configureBlocking(false);

        // 将服务器通道注册到选择器上，并监听连接事件
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("Server started on port " + PORT);

        while (true) {
            // 阻塞等待事件发生
            selector.select();

            // 获取所有已经就绪的事件
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();

            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.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("Client connected: " + clientChannel.getRemoteAddress());
                } else if (key.isReadable()) {
                    // 处理读事件
                    SocketChannel channel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
                    int len = channel.read(buffer);
                    if (len > 0) {
                        buffer.flip();
                        String message = new String(buffer.array(), 0, len, CHARSET);
                        System.out.println("Received message: " + message);
                        broadcast(selector, channel, message);
                    } else if (len == -1) {
                        channel.close();
                    }
                }
            }
        }
    }

    private static void broadcast(Selector selector, SocketChannel sender, String message) throws IOException {
        for (SelectionKey key : selector.keys()) {
            if (key.isValid() && key.channel() instanceof SocketChannel) {
                SocketChannel channel = (SocketChannel) key.channel();
                if (!channel.equals(sender)) {
                    ByteBuffer buffer = ByteBuffer.wrap(message.getBytes(CHARSET));
                    channel.write(buffer);
                }
            }
        }
    }
}

这个示例代码实现了一个简单的聊天室应用，使用 Java NIO 来实现多个客户端之间的通信。每个客户端都可以使用一个通道来进行数据的读写操作，而服务器可以使用一个选择器来监控所有的通道，从而实现多路复用。这样可以大大提高服务器的并发性能，支持大量的并发连接。

面试官：代码写的很好，下次带笔记本过来。