Java NIO 入门：用非阻塞 I/O 处理网络通信

Java NIO（New I/O）提供了面向缓冲区的 I/O API，以及用于网络通信的非阻塞模式。它常被用于需要同时维护大量连接的服务器：一个线程可以借助 Selector 关注多个连接的就绪事件，而不必为每个连接长期占用一个阻塞线程。

但“非阻塞”并不意味着程序自动变快，也不意味着一次读写就能完成一条消息。使用 NIO 时，程序需要自己处理缓冲区状态、消息边界、部分读写和连接生命周期。本文从核心概念讲起，最后实现一个可运行的 TCP 回显服务器，并提供客户端用于测试。

一、NIO 适合什么场景

网络 I/O 常见的阻塞模型是：线程调用读取方法后等待数据到达；如果一个线程负责一个连接，连接空闲时线程也可能被占用。对于连接数较多、连接大部分时间处于空闲状态的服务，这会增加线程数量和调度成本。

非阻塞 I/O 允许读取或写入操作暂时无法完成时立即返回。应用程序可以把多个通道注册到一个 Selector，等待其中某些通道变为可接受连接、可读或可写，再处理这些事件。它适用于连接数量较多、I/O 等待占比较高的场景，例如 TCP 服务端、代理和网关。

它并非所有程序的最佳选择。连接数不多、逻辑简单时，阻塞式 I/O 通常更易编写和维护。NIO 也不会自动提升 CPU 密集型工作的吞吐量；如果每次就绪事件里执行很长时间的业务逻辑，负责轮询的线程仍会被拖住。实际服务常将网络事件处理与业务计算、数据库访问等任务分开，并谨慎管理线程池和任务队列。

二、三个核心概念

Channel：数据通道

Channel 是进行 I/O 操作的通道。网络编程中常见的是 ServerSocketChannel 和 SocketChannel：前者负责接受连接，后者负责连接上的读写。通道可以设置为阻塞或非阻塞；注册到选择器的网络通道必须是非阻塞模式。

Buffer：读写缓冲区

通道通常从 ByteBuffer 读取数据，或把 ByteBuffer 中的数据写出去。缓冲区有容量、位置和上限等状态。填充缓冲区后，通常调用 flip()，让它进入可读取状态；消费完数据后调用 clear()，准备再次填充。若还需要保留尚未处理的数据，则应使用 compact()，而不是直接清空。

ByteBuffer buffer = ByteBuffer.allocate(1024);

// 写入缓冲区
buffer.put(data);

// 切换为读取模式
buffer.flip();

// 读取缓冲区中的内容
while (buffer.hasRemaining()) {
    byte value = buffer.get();
}

// 清空状态，准备重新写入
buffer.clear();

这里的 clear() 只重置位置和上限，并不会擦除底层数据。ByteBuffer 的状态转换是 NIO 初学者容易出错的地方：忘记 flip() 可能导致读取不到刚写入的内容；在未消费完时调用 clear()，则会丢弃剩余数据。

Selector：就绪事件选择器

Selector 可以监视注册到它的多个非阻塞通道。注册时指定关注的事件类型，常见的有：

• OP_ACCEPT：服务端通道可以接受连接。
• OP_CONNECT：客户端连接操作已完成或需要继续处理。
• OP_READ：通道当前可以读取数据。
• OP_WRITE：通道当前可以写入数据。

选择器报告的是“现在可以尝试进行某类 I/O”，不是“一个完整请求已经到达”，也不是“所有数据都能一次读完或写完”。TCP 是字节流协议，不保留应用层消息边界；一次 read() 可能读到半条消息，也可能读到多条消息。

三、示例协议与实现思路

下面的示例实现一个按行处理的 TCP 回显服务器：客户端以换行符 \n 结束一条消息，服务器返回“收到：”和原消息。每条消息按 UTF-8 解码。示例使用换行符作为帧分隔符，因此不适合直接承载含未转义换行符的任意二进制数据。

服务器为每个连接保存输入累积区和待发送缓冲区队列。输入数据可能分多次到达，所以要一直累积到换行符；写操作也可能只写出部分数据，所以要保留尚未写完的缓冲区，并在下次可写时继续发送。示例还限制单条输入帧长度和单连接待发送数据量，避免单个连接无限制地积累数据。

四、可运行的非阻塞 TCP 服务器

将下面代码保存为 NioEchoServer.java。示例使用 Java 8 及以上版本的标准 API，不依赖第三方库。

import java.io.ByteArrayOutputStream;
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.nio.charset.StandardCharsets;
import java.util.ArrayDeque;
import java.util.Iterator;
import java.util.Queue;

public class NioEchoServer {
    private static final int PORT = 9000;
    private static final int READ_BUFFER_SIZE = 8192;
    private static final int MAX_FRAME_BYTES = 64 * 1024;
    private static final long MAX_PENDING_WRITE_BYTES = 1024 * 1024;

    private static final class Connection {
        final ByteArrayOutputStream frame = new ByteArrayOutputStream();
        final Queue<ByteBuffer> writes = new ArrayDeque<>();
        long pendingWriteBytes;
    }

    public static void main(String[] args) throws IOException {
        try (Selector selector = Selector.open();
             ServerSocketChannel server = ServerSocketChannel.open()) {

            server.configureBlocking(false);
            server.bind(new InetSocketAddress(PORT));
            server.register(selector, SelectionKey.OP_ACCEPT);

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

            while (true) {
                selector.select();

                Iterator<SelectionKey> iterator =
                        selector.selectedKeys().iterator();

                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    iterator.remove();

                    if (!key.isValid()) {
                        continue;
                    }

                    try {
                        if (key.isAcceptable()) {
                            acceptConnections(server, selector);
                        } else {
                            if (key.isReadable()) {
                                readFromClient(key);
                            }
                            if (key.isValid() && key.isWritable()) {
                                writeToClient(key);
                            }
                        }
                    } catch (IOException e) {
                        closeKey(key);
                    }
                }
            }
        }
    }

    private static void acceptConnections(
            ServerSocketChannel server, Selector selector) throws IOException {
        SocketChannel client;
        while ((client = server.accept()) != null) {
            client.configureBlocking(false);
            client.register(selector, SelectionKey.OP_READ, new Connection());
            System.out.println("Accepted " + client.getRemoteAddress());
        }
    }

    private static void readFromClient(SelectionKey key) throws IOException {
        SocketChannel client = (SocketChannel) key.channel();
        Connection connection = (Connection) key.attachment();
        ByteBuffer input = ByteBuffer.allocate(READ_BUFFER_SIZE);

        int count = client.read(input);
        if (count == -1) {
            closeKey(key);
            return;
        }
        if (count == 0) {
            return;
        }

        input.flip();
        while (input.hasRemaining()) {
            byte value = input.get();

            if (value == '\\n') {
                byte[] bytes = connection.frame.toByteArray();
                connection.frame.reset();

                int length = bytes.length;
                if (length > 0 && bytes[length - 1] == '\\r') {
                    length--;
                }

                String message = new String(
                        bytes, 0, length, StandardCharsets.UTF_8);
                enqueueResponse(key, connection, "收到：" + message + "\\n");
            } else {
                if (connection.frame.size() >= MAX_FRAME_BYTES) {
                    closeKey(key);
                    return;
                }
                connection.frame.write(value);
            }

            if (!key.isValid()) {
                return;
            }
        }
    }

    private static void enqueueResponse(
            SelectionKey key, Connection connection, String response)
            throws IOException {
        ByteBuffer output = StandardCharsets.UTF_8.encode(response);
        int size = output.remaining();

        if (connection.pendingWriteBytes + size > MAX_PENDING_WRITE_BYTES) {
            closeKey(key);
            return;
        }

        connection.writes.add(output);
        connection.pendingWriteBytes += size;
        key.interestOps(key.interestOps() | SelectionKey.OP_WRITE);
    }

    private static void writeToClient(SelectionKey key) throws IOException {
        SocketChannel client = (SocketChannel) key.channel();
        Connection connection = (Connection) key.attachment();

        while (!connection.writes.isEmpty()) {
            ByteBuffer output = connection.writes.peek();
            int before = output.remaining();
            client.write(output);
            int written = before - output.remaining();
            connection.pendingWriteBytes -= written;

            if (output.hasRemaining()) {
                break;
            }
            connection.writes.remove();
        }

        if (connection.writes.isEmpty() && key.isValid()) {
            key.interestOps(key.interestOps() & ~SelectionKey.OP_WRITE);
        }
    }

    private static void closeKey(SelectionKey key) {
        key.cancel();
        try {
            key.channel().close();
        } catch (IOException ignored) {
            // 关闭连接时忽略后续关闭异常。
        }
    }
}

编译和运行

javac NioEchoServer.java
java NioEchoServer

服务器监听本机所有网络接口上的 TCP 端口 9000。如果端口被占用，启动会失败；选择其他可用端口时，修改代码中的 PORT 常量。操作系统、防火墙和容器网络配置也可能影响外部客户端能否访问该端口。

五、客户端测试

可以使用系统自带或单独安装的网络工具测试。例如，使用 nc 连接后输入一行文字并按回车；不同平台的 nc 参数可能略有差别。

nc 127.0.0.1 9000

也可以使用下面这个阻塞式 Java 客户端进行测试。它只用于验证服务器协议，不是非阻塞客户端的实现。将代码保存为 NioEchoClient.java，和服务器代码一起编译。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class NioEchoClient {
    public static void main(String[] args) throws Exception {
        try (Socket socket = new Socket("127.0.0.1", 9000);
             BufferedReader input = new BufferedReader(
                     new InputStreamReader(
                             socket.getInputStream(), StandardCharsets.UTF_8));
             OutputStream output = socket.getOutputStream()) {

            output.write("你好，NIO\\n".getBytes(StandardCharsets.UTF_8));
            output.flush();

            String response = input.readLine();
            System.out.println(response);
        }
    }
}

javac NioEchoServer.java NioEchoClient.java
java NioEchoServer
# 在另一个终端执行
java NioEchoClient

客户端会输出 收到：你好，NIO。测试时服务器需要先启动。注意，示例客户端只发送一条消息，并按行读取一条响应；如果服务端协议或测试输入改变，客户端也需要相应调整。

六、逐段理解服务器

1. 注册服务端通道

服务器先调用 configureBlocking(false) 设置非阻塞，再通过 register() 将服务端通道注册到选择器，并关注 OP_ACCEPT。调用 bind() 后，端口开始监听。

选择器循环调用 select()，在有就绪事件时返回。selectedKeys() 是需要由应用程序处理的就绪键集合；处理完每个键后必须从集合中删除它，否则旧键会残留在集合里，导致后续循环重复处理或出现错误判断。这里使用迭代器的 remove() 删除当前键。

2. 接受新连接

accept() 在非阻塞模式下可能返回 null，表示此刻没有待处理的连接。代码用循环持续接受连接，直到返回 null。每个新建的 SocketChannel 也要设置为非阻塞模式，然后注册 OP_READ，并将该连接的状态对象作为 attachment 保存。

连接状态不能只放在局部变量里。一次就绪事件结束后，下一次读写可能发生在之后的选择器循环，因此要为每个连接保留未完成的输入帧和待发送数据。

3. 处理读取与消息边界

read() 的返回值需要分别处理：返回负数表示对端已关闭输出流，返回零表示本次没有读取到数据，正数表示实际读取的字节数。不能把“没有读到数据”当作连接关闭，也不能假定正数等于缓冲区容量。

TCP 提供的是有序字节流，不提供请求边界。示例逐字节检查换行符，并把其他字节保存到当前帧中。换行符可能落在任意一次读取的开头、中间或末尾；这种写法可以处理帧跨多次读取的情况，也能在一次读取中处理多条完整消息。

输入上限 MAX_FRAME_BYTES 是示例自行实施的协议限制，不是 Java NIO 或 TCP 的固定参数限制。超过上限时示例关闭连接。生产环境应根据协议设计和资源预算明确设置帧大小，并考虑客户端持续发送未结束帧的情况。

4. 处理部分写入

非阻塞模式下，write() 可能只写出缓冲区的一部分，甚至暂时写出零字节。只要 ByteBuffer.hasRemaining() 为真，就必须保留该缓冲区，等待后续可写事件继续发送。示例将待发送缓冲区放在队列中，并在队列非空时注册 OP_WRITE。

不要一直关注 OP_WRITE。很多连接在大多数时间都可写；若始终注册写事件，选择器可能频繁返回，造成空转。队列排空后，代码移除 OP_WRITE，仅在又有响应排队时重新添加。

示例按每个连接限制了待发送字节数，但这不等于限制了服务器的总内存使用。大量连接同时排队时，累计内存仍可能很高。线上实现通常还要设置全局预算、连接数上限和背压策略，例如在积压过多时暂停读取、拒绝请求或断开连接。

七、关键边界与常见错误

把一次读取误认为一条消息

这是最常见的协议错误。TCP 可能把一条消息分成多次到达，也可能把多条消息合并到一次读取中。需要在应用层定义消息边界，例如分隔符、固定长度或长度前缀，并实现跨缓冲区的累积与拆帧逻辑。

分隔符协议要处理分隔符在数据中的转义规则、最大帧大小和字符编码问题；长度前缀协议要先读完整长度字段，再验证长度是否在允许范围内，之后才能分配或累积对应的数据。不能未经验证就按照客户端提供的长度分配大数组。

忽略部分写入

对非阻塞通道调用 write() 后，缓冲区可能没有完全写空。若在这种情况下丢弃缓冲区，响应就会被截断。正确做法是保留缓冲区及其当前位置，等后续可写事件继续写，直到没有剩余字节。

缓冲区模式切换不正确

从写模式切换到读模式通常需要 flip()；读完后可调用 clear() 重用缓冲区。如果一轮读操作没有处理完缓冲区中所有字节，应使用 compact() 等方式保留未处理部分。缓冲区状态与实际数据处理进度必须保持一致。

遗漏键的生命周期管理

连接关闭或 I/O 出错后，应取消对应的 SelectionKey 并关闭通道。示例对单个连接的 IOException 进行处理，避免一个客户端异常直接终止整个事件循环。更复杂的服务器还需区分可恢复错误、协议错误和服务级错误，并记录有用的连接信息。

在选择器线程执行慢操作

选择器线程如果同步执行慢速数据库查询、远程调用或耗时计算，就无法及时处理其他连接的事件。常见做法是把业务工作提交给有界任务队列和工作线程，再将处理结果交回 I/O 线程写出。队列需要有上限和明确的拒绝策略；不受限地提交任务只会把压力从连接缓冲区转移到内存队列。

忽视字符编码与分隔符

示例先按字节寻找 ASCII 换行符，再对一整帧使用 UTF-8 解码，这适用于以字节换行分帧的协议。UTF-8 多字节字符可能跨越两次网络读取，因此不应在每次读取后单独把片段转成字符串，否则字符可能被错误解码。对任意文本流，可使用能保留解码状态的 CharsetDecoder，或者先按可靠的字节级协议完成组帧，再解码完整帧。

示例使用 new String(..., UTF_8) 解码。对于不合法的 UTF-8 字节序列，该方式会以替代字符处理，而不是拒绝输入。如果协议要求严格校验编码，应使用配置为报告解码错误的 CharsetDecoder，并定义错误处理规则。

八、参数限制与安全边界

代码中的 9000 是示例监听端口，不是 NIO 专用端口，也不是操作系统保证可用的端口。实际能否绑定取决于端口是否被占用、运行权限和系统网络配置。8192 是每次读取使用的缓冲区大小，64 KiB 是示例自行设定的单帧上限，1 MiB 是单连接待发送队列上限；它们都可以根据协议与容量规划调整，调整后仍需评估并发连接下的总内存消耗。

这些限制只能控制示例代码中的部分内存路径，不代表完整的拒绝服务防护。生产服务还应考虑连接数上限、连接空闲超时、读取和写入超时策略、速率限制、认证与授权、日志敏感信息处理，以及全局资源预算。尤其是客户端不断发送数据却不结束一帧的情形，应通过帧上限和超时等措施约束。

这个回显服务没有身份认证、授权、加密或敏感信息保护能力，只适合本机或受控环境下的学习与测试。它不能作为安全服务直接暴露到公网，也不能把 TCP 端口开放误认为已建立可信连接。需要保护传输内容时，应采用经过正确配置的 TLS；需要防止未授权操作时，还必须设计身份验证、权限检查和相关协议逻辑。NIO 是 I/O API，本身不会提供这些安全保证。

九、Selector 与线程使用上的提醒

示例由一个线程独占选择器和所有连接的读写状态，这样可以避免多个线程同时修改 interestOps 或缓冲区所带来的竞态。真实项目若由其他线程提交待发送数据，通常需要安全的任务队列，并在队列更新后调用 selector.wakeup() 通知选择器线程；同时要设计清晰的所有权规则，避免缓冲区被多个线程同时读写。

select() 通常会等待事件发生，但这不意味着事件循环无需监控。服务应根据运行时行为观察 CPU、连接数、请求延迟和待写队列长度。若选择器循环异常频繁返回但没有有效工作，需检查代码是否一直保留了无用的写兴趣、是否重复处理 selected key，或是否出现其他空转条件。

十、何时使用更高层的网络框架

直接使用 NIO 有助于理解网络事件处理，也适合有明确资源模型、需要定制协议或希望减少额外依赖的项目。但完整网络服务还要处理超时、连接管理、TLS、编解码、流量控制、错误恢复和监控。若这些需求很多，使用成熟的网络框架往往更实际；框架能减少底层样板代码，但不能替代对协议、资源限制和安全边界的设计。

总结

使用 Java NIO 处理网络通信，核心是让非阻塞通道注册到选择器，并围绕就绪事件推进 I/O 状态。正确实现还必须面对 TCP 字节流的消息边界、部分读写、缓冲区状态和连接关闭。示例展示了按行组帧、限制单帧大小、排队处理部分写入以及仅在需要时关注写事件的基本做法。

理解这些边界后，再根据并发规模和运维要求决定是否直接使用 NIO、如何设置资源上限，以及是否采用更高层框架。非阻塞只是 I/O 模式之一；可靠性和安全性仍然取决于协议设计、资源管理与业务层保护。