NIO Selector选择器

NIO Selector选择器

选择器（Selector）是什么呢？选择器和通道的关系又是什么？简单地说：选择器的使命是完成IO的多路复用。一个通道代表一条连接通路，通过选择器可以同时监控多个通道的IO（输入输出）状况。选择器和通道的关系，是监控和被监控的关系。选择器提供了独特的API方法，能够选出（select）所监控的通道拥有哪些已经准备好的、就绪的IO操作事件。

1 选择器以及注册

选择器提供了独特的API方法，能够选出（select）所监控的通道拥有哪些已经准备好的、就绪的IO操作事件。

一般来说，一个单线程处理一个选择器，一个选择器可以监控很多通道。通过选择器，一个单线程可以处理数百、数千、数万、甚至更多的通道。在极端情况下（数万个连接），只用一个线程就可以处理所有的通道，这样会大量地减少线程之间上下文切换的开销。

通道和选择器之间的关系，通过register（注册）的方式完成。调用通道的Channel.register（Selector sel, int ops）方法，可以将通道实例注册到一个选择器中。register方法有两个参数：第一个参数，指定通道注册到的选择器实例；第二个参数，指定选择器要监控的IO事件类型。

（1）可读：SelectionKey.OP_READ
（2）可写：SelectionKey.OP_WRITE
（3）连接：SelectionKey.OP_CONNECT
（4）接收：SelectionKey.OP_ACCEPT

事件类型的定义在SelectionKey类中。如果选择器要监控通道的多种事件，可以用“按位或”运算符来实现。例如，同时监控可读和可写IO事件：

        //监控通道的多种事件，用“按位或”运算符来实现
        int key = SelectionKey.OP_READ | SelectionKey.OP_WRITE ;

什么是IO事件呢？这个概念容易混淆，这里特别说明一下。这里的IO事件不是对通道的IO操作，而是通道的某个IO操作的一种就绪状态，表示通道具备完成某个IO操作的条件。比方说，某个SocketChannel通道，完成了和对端的握手连接，则处于“连接就绪”（OP_CONNECT）状态。再比方说，某个ServerSocketChannel服务器通道，监听到一个新连接的到来，则处于“接收就绪”（OP_ACCEPT）状态。还比方说，一个有数据可读的SocketChannel通道，处于“读就绪”（OP_READ）状态；一个等待写入数据的，处于“写就绪”（OP_WRITE）状态。

2 SelectableChannel可选择通道

并不是所有的通道，都是可以被选择器监控或选择的。比方说，FileChannel文件通道就不能被选择器复用。判断一个通道能否被选择器监控或选择，有一个前提：判断它是否继承了抽象类SelectableChannel（可选择通道）。如果继承了SelectableChannel，则可以被选择，否则不能。简单地说，一条通道若能被选择，必须继承SelectableChannel类。SelectableChannel类，是何方神圣呢？它提供了实现通道的可选择性所需要的公共方法。Java NIO中所有网络链接Socket套接字通道，都继承了SelectableChannel类，都是可选择的。而FileChannel文件通道，并没有继承SelectableChannel，因此不是可选择通道。

3 SelectionKey选择键

通道和选择器的监控关系注册成功后，就可以选择就绪事件。具体的选择工作，和调用选择器Selector的select()方法来完成。通过select方法，选择器可以不断地选择通道中所发生操作的就绪状态，返回注册过的感兴趣的那些IO事件。换句话说，一旦在通道中发生了某些IO事件（就绪状态达成），并且是在选择器中注册过的IO事件，就会被选择器选中，并放入SelectionKey选择键的集合中。

这里出现一个新的概念——SelectionKey选择键。SelectionKey选择键是什么呢？简单地说，SelectionKey选择键就是那些被选择器选中的IO事件。前面讲到，一个IO事件发生（就绪状态达成）后，如果之前在选择器中注册过，就会被选择器选中，并放入SelectionKey选择键集合中；如果之前没有注册过，即使发生了IO事件，也不会被选择器选中。SelectionKey选择键和IO的关系，可以简单地理解为：选择键，就是被选中了的IO事件。

在编程时，选择键的功能是很强大的。通过SelectionKey选择键，不仅仅可以获得通道的IO事件类型，比方说SelectionKey.OP_READ；还可以获得发生IO事件所在的通道；另外，也可以获得选出选择键的选择器实例。

使用选择器，主要有以下三步：
（1）获取选择器实例；（2）将通道注册到选择器中；（3）轮询感兴趣的IO就绪事件（选择键集合）。

第一步：获取选择器实例选择器实例是通过调用静态工厂方法open()来获取的，具体如下：

        //调用静态工厂方法open()来获取Selector实例
        Selector selector = Selector.open();

Selector选择器的类方法open()的内部，是向选择器SPI（SelectorProvider）发出请求，通过默认的SelectorProvider（选择器提供者）对象，获取一个新的选择器实例。Java中SPI全称为（Service Provider Interface，服务提供者接口），是JDK的一种可以扩展的服务提供和发现机制。Java通过SPI的方式，提供选择器的默认实现版本。也就是说，其他的服务提供商可以通过SPI的方式，提供定制化版本的选择器的动态替换或者扩展。

第二步：将通道注册到选择器实例

要实现选择器管理通道，需要将通道注册到相应的选择器上，简单的示例代码如下：

        // 2．获取通道
        ServerSocketChannelserverSocketChannel = ServerSocketChannel.open();
        // 3．设置为非阻塞
        serverSocketChannel.configureBlocking(false);
        // 4．绑定连接
        serverSocketChannel.bind(new
    InetSocketAddress(SystemConfig.SOCKET_SERVER_PORT));
        // 5．将通道注册到选择器上，并制定监听事件为：“接收连接”事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

上面通过调用通道的register()方法，将ServerSocketChannel通道注册到了一个选择器上。当然，在注册之前，首先要准备好通道。

这里需要注意：注册到选择器的通道，必须处于非阻塞模式下，否则将抛出IllegalBlockingModeException异常。这意味着，FileChannel文件通道不能与选择器一起使用，因为FileChannel文件通道只有阻塞模式，不能切换到非阻塞模式；而Socket套接字相关的所有通道都可以。

其次，还需要注意：一个通道，并不一定要支持所有的四种IO事件。例如服务器监听通道ServerSocketChannel，仅仅支持Accept（接收到新连接）IO事件；而SocketChannel传输通道，则不支持Accept（接收到新连接）IO事件。

如何判断通道支持哪些事件呢？可以在注册之前，可以通过通道的validOps()方法，来获取该通道所有支持的IO事件集合。

第三步：选出感兴趣的IO就绪事件（选择键集合）

通过Selector选择器的select()方法，选出已经注册的、已经就绪的IO事件，保存到SelectionKey选择键集合中。SelectionKey集合保存在选择器实例内部，是一个元素为SelectionKey类型的集合（Set）。调用选择器的selectedKeys()方法，可以取得选择键集合。

接下来，需要迭代集合的每一个选择键，根据具体IO事件类型，执行对应的业务操作。大致的处理流程如下：

        //轮询，选择感兴趣的IO就绪事件（选择键集合）
        while (selector.select() > 0) {
            Set selectedKeys = selector.selectedKeys();
            Iterator keyIterator = selectedKeys.iterator();
            while(keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();
        //根据具体的IO事件类型，执行对应的业务操作
                if(key.isAcceptable()) {
                // IO事件：ServerSocketChannel服务器监听通道有新连接
                } else if (key.isConnectable()) {
                // IO事件：传输通道连接成功
                } else if (key.isReadable()) {
                // IO事件：传输通道可读
                } else if (key.isWritable()) {
                // IO事件：传输通道可写
                }
                //处理完成后，移除选择键
                keyIterator.remove();
            }
        }

处理完成后，需要将选择键从这个SelectionKey集合中移除，防止下一次循环的时候，被重复的处理。SelectionKey集合不能添加元素，如果试图向SelectionKey选择键集合中添加元素，则将抛出java.lang.UnsupportedOperationException异常。

用于选择就绪的IO事件的select()方法，有多个重载的实现版本，具体如下：（1）select()：阻塞调用，一直到至少有一个通道发生了注册的IO事件。（2）select(long timeout)：和select()一样，但最长阻塞时间为timeout指定的毫秒数。（3）selectNow()：非阻塞，不管有没有IO事件，都会立刻返回。select()方法返回的整数值（int整数类型），表示发生了IO事件的通道数量。更准确地说，是从上一次select到这一次select之间，有多少通道发生了IO事件。强调一下，select()方法返回的数量，指的是通道数，而不是IO事件数，准确地说，是指发生了选择器感兴趣的IO事件的通道数。

.5 使用NIO实现Discard服务器的实践案例

Discard服务器的功能很简单：仅仅读取客户端通道的输入数据，读取完成后直接关闭客户端通道；并且读取到的数据直接抛弃掉（Discard）。Discard服务器足够简单明了，作为第一个学习NIO的通信实例，较有参考价值。下面的Discard服务器代码，将选择器使用流程中的步骤进行了细化：

        package com.crazymakercircle.iodemo.NioDiscard;
        //...
        public class NioDiscardServer {
            public static void startServer() throws IOException {
              // 1．获取选择器
              Selector selector = Selector.open();
              // 2．获取通道
              ServerSocketChannelserverSocketChannel = ServerSocketChannel.open();
              // 3．设置为非阻塞
              serverSocketChannel.configureBlocking(false);
              // 4．绑定连接
              serverSocketChannel.bind(newInetSocketAddress(NioDemoConfig
                                        .SOCKET_SERVER_PORT));
              Logger.info("服务器启动成功");
              // 5．将通道注册的“接收新连接”IO事件，注册到选择器上
              serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
              // 6．轮询感兴趣的IO就绪事件（选择键集合）
              while (selector.select() > 0) {
                  // 7．获取选择键集合
                  Iterator<SelectionKey>selectedKeys = selector.selectedKeys().
                                                        iterator();
                  while (selectedKeys.hasNext()) {
                      // 8．获取单个的选择键，并处理
                      SelectionKeyselectedKey = selectedKeys.next();
                      // 9．判断key是具体的什么事件
                      if (selectedKey.isAcceptable()) {
                        // 10．若选择键的IO事件是“连接就绪”事件，就获取客户端连接
                        SocketChannelsocketChannel = serverSocketChannel.accept();
                        // 11．切换为非阻塞模式
                        socketChannel.configureBlocking(false);
                        // 12．将该新连接的通道的可读事件，注册到选择器上
                        socketChannel.register(selector, SelectionKey.OP_READ);
                      } else if (selectedKey.isReadable()) {
                        // 13．若选择键的IO事件是“可读”事件，读取数据
                        SocketChannelsocketChannel = (SocketChannel) selectedKey.
                                                        channel();
                        // 14．读取数据，然后丢弃
                        ByteBufferbyteBuffer = ByteBuffer.allocate(1024);
                        int length = 0;
                        while ((length = socketChannel.read(byteBuffer)) >0) {
                            byteBuffer.flip();
                            Logger.info(new String(byteBuffer.array(), 0, length));
                            byteBuffer.clear();
                        }
                        socketChannel.close();
                      }
                      // 15．移除选择键
                      selectedKeys.remove();
                  }
              }
              // 16．关闭连接
              serverSocketChannel.close();
            }
            public static void main(String[] args) throws IOException {
              startServer();
            }
        }

实现DiscardServer一共分为16步，其中第7到第15步是循环执行的。不断选择感兴趣的IO事件到选择器的选择键集合中，然后通过selector.selectedKeys()获取该选择键集合，并且进行迭代处理。对于新建立的socketChannel客户端传输通道，也要注册到同一个选择器上，使用同一个选择线程，不断地对所有的注册通道进行选择键的选择。

在DiscardServer程序中，涉及到两次选择器注册：一次是注册serverChannel服务器通道；另一次，注册接收到的socketChannel客户端传输通道。serverChannel服务器通道注册的，是新连接的IO事件SelectionKey.OP_ACCEPT；客户端socketChannel传输通道注册的，是可读IO事件SelectionKey.OP_READ。

DiscardServer在对选择键进行处理时，通过对类型进行判断，然后进行相应的处理

（1）如果是SelectionKey.OP_ACCEPT新连接事件类型，代表serverChannel服务器通道发生了新连接事件，则通过服务器通道的accept方法，获取新的socketChannel传输通道，并且将新通道注册到选择器。

（2）如果是SelectionKey.OP_READ可读事件类型，代表某个客户端通道有数据可读，则读取选择键中socketChannel传输通道的数据，然后丢弃。

客户端的DiscardClient代码，则更为简单。客户端首先建立到服务器的连接，发送一些简单的数据，然后直接关闭连接。代码如下：

        package com.crazymakercircle.iodemo.NioDiscard;
        //...
        public class NioDiscardClient {
            public static void startClient() throws IOException {
              InetSocketAddress address =new InetSocketAddress(NioDemoConfig.
                            SOCKET_SERVER_IP, NioDemoConfig.SOCKET_SERVER_PORT);
              // 1．获取通道
              SocketChannelsocketChannel = SocketChannel.open(address);
              // 2．切换成非阻塞模式
              socketChannel.configureBlocking(false);
              //不断地自旋、等待连接完成，或者做一些其他的事情
              while (! socketChannel.finishConnect()) {
              }
              Logger.info("客户端连接成功");
              // 3．分配指定大小的缓冲区
              ByteBufferbyteBuffer = ByteBuffer.allocate(1024);
              byteBuffer.put("hello world".getBytes());
              byteBuffer.flip();
              //发送到服务器
              socketChannel.write(byteBuffer);
              socketChannel.shutdownOutput();
              socketChannel.close();
            }
            public static void main(String[] args) throws IOException {
              startClient();
            }
        }

如果需要执行整个程序，首先要执行前面的服务器端程序，然后执行后面的客户端程序。通过Discard服务器的开发实践，大家对NIO Selector（选择）的使用流程，应该了解得非常清楚了。下面来看一个稍微复杂一点的案例：在服务器端接收文件和内容。

下面来看一个稍微复杂一点的案例：在服务器端接收文件和内容。

6 使用SocketChannel在服务器端接收文件的实践案例

本示例演示文件的接收，是服务器端的程序。和前面介绍的文件发送的SocketChannel客户端程序是相互配合使用的。由于在服务器端，需要用到选择器，所以在介绍完选择器后，才开始介绍NIO文件传输的Socket服务器端程序。服务器端接收文件的示例代码如下所示：

        package com.crazymakercircle.iodemo.socketDemos;
        //...
        public class NioReceiveServer {
            private Charset charset = Charset.forName("UTF-8");
            /＊＊
            ＊ 内部类，服务器端保存的客户端对象，对应一个客户端文件
            ＊/
            static class Client {
              //文件名称
              String fileName;
              //长度
              long fileLength;
              //开始传输的时间
              long startTime;
              //客户端的地址
              InetSocketAddressremoteAddress;
              //输出的文件通道
              FileChanneloutChannel;
          }
          private ByteBuffer buffer
                  = ByteBuffer.allocate(NioDemoConfig.SERVER_BUFFER_SIZE);
          //使用Map保存每个文件传输，当OP_READ可读时，根据通道找到对应的对象
          Map<SelectableChannel, Client>clientMap = new HashMap<SelectableChannel,
  Client>();

          public void startServer() throws IOException {
              // 1．获取选择器
              Selector selector = Selector.open();
              // 2．获取通道
              ServerSocketChannelserverChannel = ServerSocketChannel.open();
              ServerSocketserverSocket = serverChannel.socket();
              // 3．设置为非阻塞
              serverChannel.configureBlocking(false);
              // 4．绑定连接
              InetSocketAddress address
                    = new InetSocketAddress(NioDemoConfig.SOCKET_SERVER_PORT);
              serverSocket.bind(address);
              // 5．将通道注册到选择器上，并注册的IO事件为：“接收新连接”
              serverChannel.register(selector, SelectionKey.OP_ACCEPT);
              Print.tcfo("serverChannel is listening...");
              // 6．选择感兴趣的IO就绪事件（选择键集合）
              while (selector.select() > 0) {
                  // 7．获取选择键集合
                  Iterator<SelectionKey> it = selector.selectedKeys().iterator();
                  while (it.hasNext()) {
                    // 8．获取单个的选择键，并处理
                    SelectionKey key = it.next();

                    // 9．判断key是具体的什么事件，是否为新连接事件
                    if (key.isAcceptable()) {
                        // 10．若接受的事件是“新连接”事件，就获取客户端新连接
                        ServerSocketChannel server
                                    = (ServerSocketChannel) key.channel();
                        SocketChannelsocketChannel = server.accept();
                        if (socketChannel == null) continue;
                        // 11．客户端新连接，切换为非阻塞模式
                        socketChannel.configureBlocking(false);
                        // 12．将客户端新连接通道注册到选择器上
                        SelectionKeyselectionKey =
                            socketChannel.register(selector, SelectionKey.OP_READ);
                        // 为每一条传输通道，建立一个Client客户端对象，放入map，供后面使用
                        Client client = new Client();
                        client.remoteAddress
                            = (InetSocketAddress) socketChannel.getRemoteAddress();
                        clientMap.put(socketChannel, client);
                        Logger.info(socketChannel.getRemoteAddress() + "连接成
  功．..");
                    } else if (key.isReadable()) {
                        // 13．若接收的事件是“数据可读”事件，就读取客户端新连接
                        processData(key);
                      }
                    // NIO的特点只会累加，已选择的键的集合不会删除
                    // 如果不删除，下一次又会被select函数选中
                    it.remove();
                  }
              }
          }

          /＊＊
          ＊ 处理客户端传输过来的数据
          ＊/
          private void processData(SelectionKey key) throws IOException {
              Client client = clientMap.get(key.channel());
              SocketChannelsocketChannel = (SocketChannel) key.channel();
              int num = 0;
              try {
                  buffer.clear();
                  while ((num = socketChannel.read(buffer)) > 0) {
                    buffer.flip();
                    if (null == client.fileName) {
                        //客户端发送过来的，首先是文件名
                        //根据文件名，创建服务器端的文件，将文件通道保存到客户端
                        String fileName = charset.decode(buffer).toString();
                        String destPath = IOUtil.getResourcePath(
                        NioDemoConfig.SOCKET_RECEIVE_PATH);
                        File directory = new File(destPath);
                        if (! directory.exists()) {
                            directory.mkdir();
                        }
                        client.fileName = fileName;
                        String fullName = directory.getAbsolutePath()
                              + File.separatorChar + fileName;
                        Logger.info("NIO  传输目标文件：" + fullName);
                        File file = new File(fullName);
                        FileChannelfileChannel
                                = new FileOutputStream(file).getChannel();
                        client.outChannel = fileChannel;
                    }else if (0 == client.fileLength) {
                        //客户端发送过来的，其次是文件长度
                        long fileLength = buffer.getLong();
                        client.fileLength = fileLength;
                        client.startTime = System.currentTimeMillis();
                        Logger.info("NIO  传输开始：");
                        } else {
                            //客户端发送过来的，最后是文件内容，写入文件内容
                            client.outChannel.write(buffer);
                        }
                    buffer.clear();
                  }
                  key.cancel();
              } catch (IOException e) {
                  key.cancel();
                  e.printStackTrace();
                  return;
              }
              // 读取数量-1，表示客户端传输结束标志到了
              if (num == -1) {
                  IOUtil.closeQuietly(client.outChannel);
                  System.out.println("上传完毕");
                  key.cancel();
                  Logger.info("文件接收成功，File Name:" + client.fileName);
                  Logger.info(" Size:" +
                              IOUtil.getFormatFileSize(client.fileLength));
                  long endTime = System.currentTimeMillis();
                  Logger.info("NIO IO传输毫秒数：" + (endTime - client.startTime));
              }
          }

          public static void main(String[] args) throws Exception {
              NioReceiveServer server = new NioReceiveServer();
              server.startServer();
          }
        }

由于客户端每次传输文件，都会分为多次传输：
（1）首先传入文件名称。
（2）其次是文件大小。
（3）然后是文件内容。

对应于每一个客户端socketChannel，创建一个Client客户端对象，用于保存客户端状态，分别保存文件名、文件大小和写入的目标文件通道outChannel。

socketChannel和Client对象之间是一对一的对应关系：建立连接的时候，以socketChannel作为键（Key）, Client对象作为值（Value），将Client保存在map中。当socketChannel传输通道有数据可读时，通过选择键key.channel()方法，取出IO事件所在socketChannel通道。然后通过socketChannel通道，从map中取到对应的Client对象。

接收到数据时，如果文件名为空，先处理文件名称，并把文件名保存到Client对象，同时创建服务器上的目标文件；接下来再读到数据，说明接收到了文件大小，把文件大小保存到Client对象；接下来再接到数据，说明是文件内容了，则写入Client对象的outChannel文件通道中，直到数据读取完毕。

运行方式：启动这个NioReceiveServer服务器程序后，再启动前面介绍的客户端程序NioSendClient，即可以完成文件的传输。