【Java.NIO】Channel，Selector，SelectionKey以及应用实例

Selector(选择器)是Java NIO中能够检测一到多个NIO通道，并能够知晓通道是否为诸如读写事件做好准备的组件。这样，一个单独的线程可以管理多个channel，从而管理多个网络连接。

 

1.NIO的通讯过程：

 

过程：NIO实现了IO多路复用的Ractor模型，一个线程Thread使用一个选择器Selector通过轮询的方式去监听多个通道Channel上的事件，找到IO事件已经到达的Channle执行。

原因（好处）：因为创建和切换线程的开销很大，因此使用一个线程来处理多个事件而不是一个线程处理一个事件，具有更好的性能

 

 

2.Selector的创建

通过调用Selector.open()方法创建一个Selector，

 

Selector selector = Selector.open();

 

• isOpen() —— 判断Selector是否处于打开状态。Selector对象创建后就处于打开状态了
• close() —— 当调用了Selector对象的close()方法，就进入关闭状态.。用完Selector后调用其close()方法会关闭该Selector，且使注册到该Selector上的所有SelectionKey实例无效。通道本身并不会关闭

 

 

3.向Selector注册通道

为了将Channel和Selector配合使用，必须将channel注册到selector上。

通过SelectableChannel的register()方法来实现。

 

4.register()返回值 —— SelectionKey,  Selector中的SelectionKey集合

只要ServerSocketChannel及SocketChannel向Selector注册了特定的事件，Selector就会监控这些事件是否发生。

SelectableChannel的register()方法返回一个SelectionKey对象，该对象是用于跟踪这些被注册事件的句柄。

一个Selector对象会包含3种类型的SelectionKey集合：

• all-keys集合 —— 当前所有向Selector注册的SelectionKey的集合，Selector的keys()方法返回该集合
• selected-keys集合 —— 相关事件已经被Selector捕获的SelectionKey的集合，Selector的selectedKeys()方法返回该集合
• cancelled-keys集合 —— 已经被取消的SelectionKey的集合，Selector没有提供访问这种集合的方法

 

• 

 

当register()方法执行时，新建一个SelectioKey，并把它加入Selector的all-keys集合中。

如果关闭了与SelectionKey对象关联的Channel对象，或者调用了SelectionKey对象的cancel方法，这个SelectionKey对象就会被加入到cancelled-keys集合中，表示这个SelectionKey对象已经被取消。

在执行Selector的select()方法时，如果与SelectionKey相关的事件发生了，这个SelectionKey就被加入到selected-keys集合中，程序直接调用selected-keys集合的remove()方法，或者调用它的iterator的remove()方法，都可以从selected-keys集合中删除一个SelectionKey对象。

 

5.SelectionKey

表示SelectableChannel 在 Selector 中的注册的标记/句柄。

register()方法返回一个SelectinKey对象，这个对象包含一些你感兴趣的属性：

• interest集合
• ready集合
• Channel
• Selector
• 附加的对象

通过调用某个SelectionKey的cancel()方法，关闭其通道，或者通过关闭其选择器来取消该Key之前，它一直保持有效。

取消某个Key之后不会立即从Selector中移除它，相反，会将该Key添加到Selector的已取消key set，以便在下一次进行选择操作的时候移除它。

 

• interest集合 —— 感兴趣的事件集合，可以通过SelectionKey读写interest集合

• ready集合 —— 是通道已经准备就绪的操作的集合，在一个选择后，你会是首先访问这个ready set，

int readySet = selectionKey.readyOps();

 

 

可以向检测interet集合那样的方法，来检测channel中什么事件或操作已经就绪，也可以使用一下四个方法，

 

 

• 从SelectionKey获取Channel和Selector：

 

• 附加的对象 —— 可以将一个对象或者更多的信息附着到SelectionKey上，这样就能方便的识别某个给定的通道。例如，可以附加与通道一起使用的Buffer，或是包含聚集数据的某个对象

 

6.通过Selector选择就绪的通道

一旦向Selector注册了一个或多个通道，就可以调用几个重载的select()方法。

这些方法返回你所感兴趣的事件（连接，接受，读或写）已经准备就绪的那些通道。换句话说，如果你对”读就绪“的通道感兴趣，select()方法会返回读事件已经就绪的那些通道。

 

• select() —— 阻塞到至少有一个通道在你注册的事件上就绪了
• select(long timeout) —— 和select()一样，除了最长会阻塞timeout毫秒
• selectNow() —— 不会阻塞，不管什么通道就绪都立刻返回；此方法执行非阻塞的选择操作，如果自从上一次选择操作后，没有通道变成可选择的，则此方法直接返回0
• select()方法返回的Int值表示多少通道就绪。

 

 

一旦调用了select()方法，并且返回值表明有一个或更多个通道就绪了，然后可以通过调用selector的selectorKeys()方法，访问”已选择键集“中的就绪通道，

 

可以遍历这个已选择的集合来访问就绪的通道：

 

这个循环遍历已选择集中的每个键，并检测各个键所对象的通道的就绪事件。

注意每次迭代末尾的remove()调用，Selector不会自己从已选择集中移除SelectioKey实例，必须在处理完通道时自己移除。

 

7.Selector的wakeUp()方法

某个线程调用select()方法后阻塞了，即使没有通道已经就绪，也有办法让其从select()方法返回。只要让其他线程在第一个线程调用select()方法的那个对象上调用Selector.wakeup()方法即可。阻塞在select()方法上的线程会立马返回。

 

 

一个示例

客户端：

/**
 * Created by Davie on 2018/8/23.
 */
public class NIOClient {
    public static void main(String[] args) throws IOException
    {
        Socket socket = new Socket("127.0.0.1",8888);
        OutputStream out = socket.getOutputStream();
        String string = "hello world";
        out.write(string.getBytes());
        out.close();
        socket.close();
    }
}

 

 

服务器端：

/**
 * Created by Davie on 2018/8/23.
 */
public class NIOServer {
    public static void main(String[] args) throws IOException
    {
        //创建选择器
        Selector selector = Selector.open();

        //将通道注册到选择器上
        ServerSocketChannel ssChannel = ServerSocketChannel.open();
        /**
         * 注意：
         * （1）通道必须配置为 非阻塞 模式，否则使用选择器没有任何意义
         * 因为如果通道在某个事件上被阻塞，那么服务器就不能响应其他事件，必须等待这个事件处理完毕才能去处理其他事件
         * （2）通道主要分为两大类：文件（File）通道 和 套接字（Socket）通道
         *   涉及的类主要有FileChannel 类 和 三个Socket通道类：SocketChannel、ServerSocketChannel和DatagramChannel
         *   应该注意的是：只有套接字Channel才能配置为 非阻塞，而FileChannel不能，为FileChannel配置为 非阻塞没有意义
         *
         */
        ssChannel.configureBlocking(false);
        /**
         * 注册的具体事件：主要有一下几类：
         *      SelectionKey.OP_CONNECT  --- 连接就绪事件，表示客户端与服务器的连接已经建立成功
         *      SelectionKey.OP_ACCEPT   --- 接收连接事件，表示服务器监听到了客户连接，服务器可以接收这个连接了
         *      SelectionKey.OP_READ     --- 读 就绪事件，表示通道中已经有了可读的数据，可以执行读操作了
         *      SelectionKey.OP_WRITE    --- 写 就绪事件，表示已经可以向通道写数据了
         */
        ssChannel.register(selector, SelectionKey.OP_ACCEPT);

        //创建服务器对象
        ServerSocket serverSocket = ssChannel.socket();
        InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8888);
        serverSocket.bind(address);

        while (true) {
            //阻塞到至少有一个通道在你注册的选择器上就绪了
            selector.select();
            /**
             *    selector.keys():当前所有向Selector注册的SelectionKey集合
             *    selector.selectedKeys()：相关事件已经被Selector捕获的SelectionKey集合
             */
            Set selectionKeys = selector.selectedKeys();
            Iterator keyIterator = selectionKeys.iterator();
            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();
                //服务器监听到了一个客户端连接
                if (key.isAcceptable()) {
                   ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
                    // 服务器会为每个新的客户端连接创建一个 SocketChannel
                    SocketChannel sChannel = serverSocketChannel.accept();
                    //配置为 非阻塞 模式
                    sChannel.configureBlocking(false);
                    // 这个新连接主要用于从客户端读取数据
                    sChannel.register(selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) {
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    System.out.println(readDataFromSocketChannel(socketChannel));
                    socketChannel.close();
                }
                /**
                 * 每次迭代末尾的remove()调用，Selector不会自己从已选择的SelectionKey集合中
                 * 移除SelectionKey实例的，必须在处理完通道时自己移除
                 */
                keyIterator.remove();
            }
        }
    }

    private static String readDataFromSocketChannel(SocketChannel sChannel) throws IOException {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        StringBuilder data = new StringBuilder();
        while (true) {
            buffer.clear();
            int n = sChannel.read(buffer);
            if (n == -1) {
                break;
            }
            buffer.flip();
            int limit = buffer.limit();
            char[] dst = new char[limit];
            for (int i = 0; i < limit; i++) {
                dst[i] = (char) buffer.get(i);
            }
            data.append(dst);
            buffer.clear();
        }
        return data.toString();
    }
}