选择器 Selector 是 I/O 多路复用模型的核心组件，它可以监控实现了 SelectableChannel 接口的通道的就绪情况。基于多路复用(multiplexing) I/O 模型，单线程的 Java 程序能够处理数万个连接，极大提高了系统的并发数。
1. 多路复用 I/O 模型
I/O 多路复用模型是操作系统提供给应用程序的一种进行 I/O 操作的模型。应用程序通过 select/poll 系统调用监控多个 I/O 设备，一旦某个或者多个 I/O 设备的处于就绪状态（例如：可读）则返回，应用程序随后可对就绪的设备进行操作。
大致流程如下：
1）应用程序向内核发起 select 系统调用，该调用会阻塞应用程序。
2）内核等待数据到达。数据可能由 DMA 复制到内核缓冲区，也有可能是 CPU 进行复制。
3）数据准备完毕，select 调用返回。select 返回的是一个集和，可能有多个连接都已经就绪。
4）应用程序发起 read 系统调用。
5）操作系统将数据有内核缓冲区复制到用户缓冲区。
6）read 调用返回。
I/O 多路复用模型本质上是一种阻塞 I/O，进行读操作的 read 系统调用是阻塞的，select 的时候也是阻塞的。不过 I/O 多路复用模型的优势在于阻塞时可以等待多路 I/O 就绪，然后一并处理。与多线程处理多路 I/O 相比，它是单线程的，没有线程切换的开销，单位时间内能够处理多的连接数。
2. 选择器与通道关系
在 Java 中，通道 Channel 可以表示 I/O 连接，而选择器可以监控某些 I/O 事件就绪的通道，选择通道中就绪的 I/O 事件。这里的通道必须是实现了 SelectableChannel 接口的通道，例如：SocketChannel, DatagramChannel 等；而文件通道 FileChannel 没有实现该接口，所以不支持选择器。
3. 选择键 SelectionKey
选择器 Selector 监控通道时监控的是通道中的事件，选择键 SelectionKey 就代表着 I/O 事件。程序通过调用 Selector.select() 方法来选中选择器所监控的通道中的就绪的 I/O 事件的集合，然后遍历集合，对事件作出相应的处理。
选择键 SelectionKey 可以表示 4 种事件，这 4 种事件使用 int 类型的常量来表示。
1）SelectionKey.OP_ACCEPT 表示 accept 事件就绪。例如：对于 ServerSocketChannel 来说，该事件就绪表示可以调用 accept() 方法来获得与客户端连接的通道 SocketChannel。
2）SelectionKey.OP_CONNECT 表示客户端与服务端连接成功。
3）SelectionKey.OP_READ 表示通道中已经有了可读数据，可以调用 read() 方法从通道中读取数据。
4）SelectionKey.OP_WRITE 表示写事件就绪，可以调用 write() 方法往通道中写入数据。
不同的通道所能够支持的 I/O 事件不同，例如：ServerSocketChannel 只支持 accept 事件，而 DatagramChannel 只支持 read 和 write 事件。要查看通道所支持的事件，可以查看通道的 javadoc 文档，或者调用通道的 validOps() 方法来进行判断。例如：channel.validOps() & SelectionKey.OP_READ > 0 表示 channel 支持读事件。
4. 选择器使用步骤
4.1 获取选择器
与通道和缓冲区的获取类似，选择器的获取也是通过静态工厂方法 open() 来得到的。
Selector selector = Selector.open(); // 获取一个选择器实例 4.2 获取可选择通道
能够被选择器监控的通道必须实现了 SelectableChannel 接口，并且需要将通道配置成非阻塞模式，否则后续的注册步骤会抛出 IllegalBlockingModeException。
SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("localhost", 9090)); // 打开 SocketChannel 并连接到本机 9090 端口 socketChannel.configureBlocking(false); // 配置通道为非阻塞模式 4.3 将通道注册到选择器
通道在被指定的选择器监控之前，应该先告诉选择器，并且告知监控的事件，即：将通道注册到选择器。
通道的注册通过 SelectableChannel.register(Selector selector, int ops) 来完成，ops 表示关注的事件，如果需要关注该通道的多个 I/O 事件，可以传入这些事件类型或运算之后的结果。这些事件必须是通道所支持的，否则抛出 IllegalArgumentException。
socketChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE); // 将套接字通过到注册到选择器，关注 read 和 write 事件 4.4 轮询 select 就绪事件
通过调用选择器的 Selector.select() 方法可以获取就绪事件，该方法会将就绪事件放到一个 SelectionKey 集合中，然后返回就绪的事件的个数。这个方法映射多路复用 I/O 模型中的 select 系统调用，它是一个阻塞方法。正常情况下，直到至少有一个就绪事件，或者其它线程调用了当前 Selector 对象的 wakeup() 方法，或者当前线程被中断时返回。
while (selector.select() > 0){ // 轮询，且返回时有就绪事件 Set<SelectionKey> keys = selector.selectedKeys(); // 获取就绪事件集合 ....... } 有 3 种方式可以 select 就绪事件：
1）select() 阻塞方法，有一个就绪事件，或者其它线程调用了 wakeup() 或者当前线程被中断时返回。
2）select(long timeout) 阻塞方法，有一个就绪事件，或者其它线程调用了 wakeup()，或者当前线程被中断，或者阻塞时长达到了 timeout 时返回。不抛出超时异常。
3）selectNode() 不阻塞，如果无就绪事件，则返回 0；如果有就绪事件，则将就绪事件放到一个集合，返回就绪事件的数量。
4.5 处理就绪事件
每次可以 select 出一批就绪的事件，所以需要对这些事件进行迭代。从一个 SelectionKey 对象可以得到：1）就绪事件的对应的通道；2）就绪的事件。通过这些信息，就可以很方便地进行 I/O 操作。
for(SelectionKey key : keys){ if(key.isWritable()){ // 可写事件 if("Bye".equals( (line = scanner.nextLine()) )){ socketChannel.shutdownOutput(); socketChannel.close(); break; } buf.put(line.getBytes()); buf.flip(); socketChannel.write(buf); buf.compact(); } } keys.clear(); // 清除选择键（事件）集，避免下次循环的时候重复处理。 需要注意的是，处理完 I/O 事件之后，需要清除选择键集合，避免下一轮循环的时候对同一事件重复处理。
5. 完整示例
下面给出一个完整的实例，实例中包含 TCP 客户端 TcpClient, UDP 客户端 UdpClient 和服务端 EchoServer。服务端 EchoServer 可以同时处理 UDP 请求和 TCP 请求，用户可以在客户端控制台输入内容，按回车发送给服务端，服务端打印客户端发送过来的内容。完整代码：https://github.com/Robothy/java-experiments/tree/main/nio/Selector
5.1 服务端
public class EchoServer { public static void main(String[] args) throws IOException { Selector selector = Selector.open(); // 获取选择器 ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); // 打开服务器通道 serverSocketChannel.configureBlocking(false); // 服务器通道配置为非阻塞模式 serverSocketChannel.bind(new InetSocketAddress(9090)); // 绑定 TCP 端口 9090 serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); // 将服务器通道注册到选择器 selector 中，注册事件为 ACCEPT DatagramChannel datagramChannel = DatagramChannel.open(); // 打开套接字通道 datagramChannel.configureBlocking(false); // 配置通道为非阻塞模式 datagramChannel.bind(new InetSocketAddress(9090)); // 绑定 UDP 端口 9090 datagramChannel.register(selector, SelectionKey.OP_READ); // 将通道注册到选择器 selector 中，注册事件为读取数据 ByteBuffer buf = ByteBuffer.allocate(1024); // 分配一个 1024 字节的堆字节缓冲区 while (selector.select() > 0){ // 轮询已经就绪的注册的通道的 I/O 事件 Set<SelectionKey> keys = selector.selectedKeys(); // 获取就绪的 I/O 事件，即选择器键集合 for (SelectionKey key : keys){ // 遍历选择键，处理就绪事件 if(key.isAcceptable()){ // 选择键的事件的是 I/O 连接事件 SocketChannel socketChannel = serverSocketChannel.accept(); // 执行 I/O 操作，获取套接字连接通道 socketChannel.configureBlocking(false); // 配置为套接字通道为非阻塞模式 socketChannel.register(selector, SelectionKey.OP_READ); // 将套接字通过到注册到选择器，关注 READ 事件 }else if(key.isReadable()){ // 选择键的事件是 READ StringBuilder sb = new StringBuilder(); if(key.channel() instanceof DatagramChannel){ // 选择的通道为数据报通道，客户端是通过 UDP 连接过来的 sb.append("UDP Client: "); datagramChannel.receive(buf); // 最多读取 1024 字节，数据报多出的部分自动丢弃 buf.flip(); while(buf.position() < buf.limit()) { sb.append((char)buf.get()); } buf.clear(); }else{ // 选择的通道为套接字通道，客户端时通过 TCP 连接过来的 sb.append("TCP Client: "); ReadableByteChannel channel = (ReadableByteChannel) key.channel(); // 获取通道 int size; while ( (size = channel.read(buf))>0){ buf.flip(); while (buf.position() < buf.limit()) { sb.append((char)buf.get()); } buf.clear(); } if (size == -1) { sb.append("Exit"); channel.close(); } } System.out.println(sb); } } keys.clear(); // 将选择键清空，防止下次循环时被重复处理 } } } 5.2 TCP 客户端
public class TcpClient { public static void main(String[] args) throws IOException { Selector selector = Selector.open(); SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("localhost", 9090)); socketChannel.configureBlocking(false); socketChannel.register(selector, SelectionKey.OP_WRITE); Scanner scanner = new Scanner(System.in); String line; ByteBuffer buf = ByteBuffer.allocate(1024); while (selector.select() > 0){ Set<SelectionKey> keys = selector.selectedKeys(); for(SelectionKey key : keys){ if(key.isWritable()){ if("Bye".equals( (line = scanner.nextLine()) )){ socketChannel.shutdownOutput(); socketChannel.close(); break; } buf.put(line.getBytes()); buf.flip(); socketChannel.write(buf); buf.compact(); } } keys.clear(); if(!socketChannel.isOpen()) break; } } } 5.3 UDP 客户端
public class UdpClient { public static void main(String[] args) throws IOException { Selector selector = Selector.open(); // 获取选择器 DatagramChannel datagramChannel = DatagramChannel.open(); // 打开一个数据报通道 datagramChannel.configureBlocking(false); // 配置通道为非阻塞模式 datagramChannel.register(selector, SelectionKey.OP_WRITE); // 将通道的写事件注册到选择器 ByteBuffer buff = ByteBuffer.allocate(1024); // 分配字节缓冲区 Scanner scanner = new Scanner(System.in); // 创建扫描器，扫描控制台输入流 InetSocketAddress server = new InetSocketAddress("localhost", 9090); while (selector.select() > 0){ // 有就绪事件 Set<SelectionKey> keys = selector.selectedKeys(); // 获取选择键，即就绪的事件 for(SelectionKey key : keys){ // 遍历选择键 if(key.isWritable()){ // 如果当前选择键是读就绪 String line; if("Bye".equals( line = scanner.nextLine() )) { // 从控制台获取 1 行输入，并检查输入的是不是 Bye System.exit(0); // 正常退出 } buff.put(line.getBytes()); // 放入缓冲区 buff.flip(); // 将缓冲区置为读状态 datagramChannel.send(buff, server); // 往 I/O 写数据 buff.compact(); // 压缩缓冲区，保留没发送完的数据 } } keys.clear(); } } } 6. 小结
Selector 作为多路复用 I/O 模型的核心组件，能够同时监控多路 I/O 通道。选择器在 select 就绪事件地时候会阻塞，在处理 I/O 事件的时候也会阻塞，它的优势在于在阻塞的时候可以等待多路 I/O 就绪，是一种异步阻塞 I/O 模型。与多线程处理多路 I/O 相比，多路复用模型只需要单个线程即可处理万级连接，没有线程切换的开销。