Java NIO Selector 详解 | Baeldung中文网

1. 概述

本文将深入探讨 Java NIO 中 Selector 组件的核心概念。Selector 提供了一种监控多个 NIO 通道的机制，当其中任意通道准备好进行数据传输时，它能及时通知我们。

通过 Selector，单个线程就能高效管理多个通道，进而处理大量网络连接。这种设计在需要处理高并发 I/O 操作的场景中尤为关键。

2. 为什么使用 Selector？

Selector 的核心价值在于：用单个线程替代多个线程管理通道。这带来两个显著优势：

✅ 降低系统开销：线程上下文切换对操作系统是昂贵的操作
✅ 节省内存资源：每个线程都需要独立的内存空间

虽然现代操作系统和 CPU 在多任务处理上不断优化，多线程开销逐渐减小，但线程数量越少，系统资源利用率越高这一原则依然成立。

Selector 不仅支持数据读取，还能监听新连接、处理慢速通道的写入操作，是构建高性能网络服务的利器。

3. 环境准备

使用 Selector 无需特殊配置，所有核心类都在 java.nio 包中。只需按需导入即可使用。

关键点：所有注册到 Selector 的通道必须是 SelectableChannel 的子类（如 SocketChannel），且必须配置为非阻塞模式。FileChannel 因无法切换为非阻塞模式，不能与 Selector 配合使用。

4. 创建 Selector

通过 Selector 的静态工厂方法创建实例，系统会使用默认的 Selector Provider：

Selector selector = Selector.open();

5. 注册可选择的通道

注册通道前必须将其设为非阻塞模式，然后调用 register() 方法：

channel.configureBlocking(false);
SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

注册时需指定监听事件类型，通过 SelectionKey 的常量定义：

事件类型	常量	说明
连接事件	`SelectionKey.OP_CONNECT`	客户端尝试连接服务器时
接受事件	`SelectionKey.OP_ACCEPT`	服务器接受客户端连接时
可读事件	`SelectionKey.OP_READ`	通道可读取数据时
可写事件	`SelectionKey.OP_WRITE`	通道可写入数据时

返回的 SelectionKey 对象封装了通道与 Selector 的注册关系。

6. SelectionKey 对象详解

SelectionKey 是通道注册的核心载体，包含以下关键属性：

6.1. 兴趣集合（Interest Set）

定义希望监听的事件集合，通过位运算检查：

int interestSet = selectionKey.interestOps();

boolean isInterestedInAccept  = (interestSet & SelectionKey.OP_ACCEPT) != 0;
boolean isInterestedInConnect = (interestSet & SelectionKey.OP_CONNECT) != 0;
boolean isInterestedInRead    = (interestSet & SelectionKey.OP_READ) != 0;
boolean isInterestedInWrite   = (interestSet & SelectionKey.OP_WRITE) != 0;

6.2. 就绪集合（Ready Set）

表示通道已就绪的事件集合，推荐使用便捷方法检查：

selectionKey.isAcceptable();  // 是否可接受连接
selectionKey.isConnectable(); // 是否可连接
selectionKey.isReadable();    // 是否可读
selectionKey.isWritable();    // 是否可写

6.3. 关联通道

获取注册的通道：

Channel channel = key.channel();

6.4. 关联 Selector

获取关联的 Selector：

Selector selector = key.selector();

6.5. 附加对象

可向 SelectionKey 附加自定义对象（如会话 ID）：

// 方式1：直接附加
key.attach(Object);
Object obj = key.attachment();

// 方式2：注册时附加
SelectionKey key = channel.register(
  selector, SelectionKey.OP_ACCEPT, object);

7. 通道键选择

Selector 的核心操作流程：

调用 select() 阻塞等待就绪事件：

int readyChannels = selector.select(); // 返回就绪通道数

获取就绪键集合：

Set<SelectionKey> selectedKeys = selector.selectedKeys();

遍历处理就绪事件：

Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
while (keyIterator.hasNext()) {
    SelectionKey key = keyIterator.next();
    if (key.isAcceptable()) {
        // 处理连接接受
    } else if (key.isReadable()) {
        // 处理读取操作
    }
    keyIterator.remove(); // 必须手动移除已处理的键
}

⚠️ 关键点：处理完 SelectionKey 后必须手动从集合中移除，否则下次 select() 会重复处理。

8. 完整示例：Echo 服务器

下面通过一个完整的 Echo 服务器/客户端示例巩固知识。服务器将客户端消息原样返回，收到特定消息时关闭连接。

8.1. 服务器实现

public class EchoServer {
    private static final String POISON_PILL = "POISON_PILL";

    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.bind(new InetSocketAddress("localhost", 5454));
        serverSocket.configureBlocking(false);
        serverSocket.register(selector, SelectionKey.OP_ACCEPT);
        ByteBuffer buffer = ByteBuffer.allocate(256);

        while (true) {
            selector.select();
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> iter = selectedKeys.iterator();
            while (iter.hasNext()) {
                SelectionKey key = iter.next();
                if (key.isAcceptable()) {
                    register(selector, serverSocket);
                }
                if (key.isReadable()) {
                    answerWithEcho(buffer, key);
                }
                iter.remove();
            }
        }
    }

    private static void answerWithEcho(ByteBuffer buffer, SelectionKey key) 
      throws IOException {
        SocketChannel client = (SocketChannel) key.channel();
        client.read(buffer);
        if (new String(buffer.array()).trim().equals(POISON_PILL)) {
            client.close();
            System.out.println("客户端连接已关闭");
        } else {
            buffer.flip();
            client.write(buffer);
            buffer.clear();
        }
    }

    private static void register(Selector selector, ServerSocketChannel serverSocket) 
      throws IOException {
        SocketChannel client = serverSocket.accept();
        client.configureBlocking(false);
        client.register(selector, SelectionKey.OP_READ);
        System.out.println("新客户端连接");
    }
}

核心逻辑：

服务器监听 ACCEPT 事件，接受连接后注册 READ 事件
收到数据后，检查是否为终止消息（POISON_PILL）
非终止消息则原样返回（flip() 切换读写模式）

8.2. 客户端实现

public class EchoClient {
    private static SocketChannel client;
    private static ByteBuffer buffer;
    private static EchoClient instance;

    public static EchoClient start() {
        if (instance == null) instance = new EchoClient();
        return instance;
    }

    public static void stop() throws IOException {
        client.close();
    }

    private EchoClient() {
        try {
            client = SocketChannel.open(new InetSocketAddress("localhost", 5454));
            buffer = ByteBuffer.allocate(256);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public String sendMessage(String msg) {
        buffer = ByteBuffer.wrap(msg.getBytes());
        String response = null;
        try {
            client.write(buffer);
            buffer.clear();
            client.read(buffer);
            response = new String(buffer.array()).trim();
            buffer.clear();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return response;
    }
}

关键操作：

发送消息：写入缓冲区 → 通道传输
接收响应：读取通道 → 缓冲区 → 字符串

8.3. 测试用例

public class EchoTest {
    Process server;
    EchoClient client;

    @Before
    public void setup() throws IOException {
        server = EchoServer.start();
        client = EchoClient.start();
    }

    @Test
    public void givenServerClient_whenServerEchosMessage_thenCorrect() {
        String resp1 = client.sendMessage("hello");
        String resp2 = client.sendMessage("world");
        assertEquals("hello", resp1);
        assertEquals("world", resp2);
    }

    @After
    public void teardown() throws IOException {
        server.destroy();
        EchoClient.stop();
    }
}

9. Selector.wakeup() 机制

selector.select() 会阻塞线程直到有就绪事件。通过 wakeup() 可强制唤醒阻塞线程：

@Test
public void whenWakeUpCalledOnSelector_thenBlockedThreadReturns() 
  throws Exception {
    Pipe pipe = Pipe.open();
    Selector selector = Selector.open();
    pipe.source().configureBlocking(false);
    pipe.source().register(selector, SelectionKey.OP_READ);

    List<String> steps = Collections.synchronizedList(new ArrayList<>());
    CountDownLatch latch = new CountDownLatch(1);

    new Thread(() -> {
        steps.add(">> 倒计时开始");
        latch.countDown();
        try {
            steps.add(">> 进入 select 阻塞");
            selector.select();
            steps.add(">> select 返回");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }).start();

    steps.add(">> 等待倒计时");
    latch.await();
    steps.add(">> 倒计时结束");

    steps.add(">> 唤醒 Selector");
    selector.wakeup();
    pipe.source().close();

    assertThat(steps).containsExactly(
        ">> 等待倒计时",
        ">> 倒计时开始",
        ">> 进入 select 阻塞",
        ">> 倒计时结束",
        ">> 唤醒 Selector",
        ">> select 返回"
    );
}

执行流程：

子线程进入 select() 阻塞
主线程调用 wakeup() 唤醒
子线程立即从 select() 返回（无论是否有就绪事件）

10. 总结

Java NIO Selector 是构建高性能网络服务的核心组件，通过单线程管理多通道显著提升资源利用率。掌握其关键机制：

非阻塞通道注册：configureBlocking(false) + register()
事件监听处理：兴趣集合 vs 就绪集合
SelectionKey 管理：手动移除已处理键
优雅唤醒机制：wakeup() 打破阻塞

完整示例代码可在 GitHub 项目获取。踩坑提示：务必记得处理完 SelectionKey 后调用 iterator.remove()，否则会导致事件重复处理！

Persistence

REST

Security