超详细Java NIO选择器教程，轻松掌握高性能网络编程！

SelectableChannel channel = ... // 创建并打开一个通道
Selector selector = Selector.open(); // 创建一个选择器
channel.configureBlocking(false); // 设置通道为非阻塞模式
SelectionKey key = channel.register(selector, SelectionKey.OP_READ); // 将通道注册到选择器中，监听读事件

key.cancel(); // 取消注册操作

while (true) {
    int readyChannels = selector.select(); // 阻塞等待通道就绪，返回就绪通道数
    if (readyChannels == 0) {
        continue;
    }
    Set<SelectionKey> selectedKeys = selector.selectedKeys(); // 获取已就绪的SelectionKey集合
    Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
    while (keyIterator.hasNext()) {
        SelectionKey key = keyIterator.next();
        if (key.isReadable()) { // 通道可读事件就绪
            // 处理读数据操作
        }
        if (key.isWritable()) { // 通道可写事件就绪
            // 处理写数据操作
        }
        keyIterator.remove(); // 移除已处理的SelectionKey
    }
}

SelectableChannel channel = ... // 创建并打开一个通道
channel.configureBlocking(false); // 设置通道为非阻塞模式

int bytesRead = channel.read(buffer); // 读取数据到缓冲区
if (bytesRead == -1) { // 通道已经关闭
    channel.close();
} else if (bytesRead == 0) { // 没有数据可读
    // 继续处理其他通道的事件
} else { // 读取到数据
    // 处理读取到的数据
}

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

public class NioSelectorDemo {

    public static void main(String[] args) throws IOException {

        // 创建选择器
        Selector selector = Selector.open();

        // 创建服务器通道
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        InetSocketAddress address = new InetSocketAddress("localhost", 8080);

        // 绑定服务器地址
        serverChannel.bind(address);

        // 设置通道为非阻塞模式
        serverChannel.configureBlocking(false);

        // 注册通道到选择器上，并指定监听事件类型为接收连接事件
        SelectionKey key = serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("服务器启动，监听地址：" + address);

        while (true) {
            // 阻塞等待通道就绪
            int readyChannels = selector.select();
            if (readyChannels == 0) {
                continue;
            }

            // 获取已就绪的通道集合
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

            while (keyIterator.hasNext()) {
                SelectionKey selectionKey = keyIterator.next();

                if (selectionKey.isAcceptable()) { // 接收连接事件就绪
                    // 获取服务器通道
                    ServerSocketChannel server = (ServerSocketChannel) selectionKey.channel();

                    // 接收客户端连接，并注册到选择器上
                    SocketChannel client = server.accept();
                    client.configureBlocking(false);
                    client.register(selector, SelectionKey.OP_READ);

                    System.out.println("客户端连接： " + client.getRemoteAddress());

                } else if (selectionKey.isReadable()) { // 通道可读事件就绪
                    // 获取通道
                    SocketChannel client = (SocketChannel) selectionKey.channel();

                    // 读取数据
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int bytesRead = client.read(buffer);

                    if (bytesRead == -1) { // 通道已经关闭
                        client.close();
                    } else if (bytesRead == 0) { // 没有数据可读
                        continue;
                    } else { // 读取到数据
                        buffer.flip();
                        byte[] bytes = new byte[buffer.remaining()];
                        buffer.get(bytes);
                        String message = new String(bytes).trim();
                        System.out.println("收到消息：" + message);
                    }
                }

                // 移除已处理的通道
                keyIterator.remove();
            }
        }
    }
}