NIO(三)：Selector选择器

一.堵塞式与非堵塞式

在传统IO中，将数据由当前线程从客户端传入服务端，由服务端的内核进行判断传过来的数据是否合法，内核中是否存在数据。

如果不存在数据 ，并且数据并不合法，当前线程将会堵塞等待。当前线程将无法进行下一步传输，进行排队现象。降低系统性能。

为了解决这一步问题，调用资源开辟多个线程传输。

虽然线程的开辟解决了部分堵塞排队的问题，但由于并没有治理根本堵塞的原因，线程数量也是有限的。总会有堵塞的线程 ，形成排队现象。

为了根本解决堵塞的问题。NIO的非堵塞式成为了主要的传输方式。

在客户端和服务端之间将通道注册到selector选择器，由选择器进行监听channel是否进行什么操作（read（）or write（））。

当数据就绪或者准备完成时，由selector进行分配到服务端的一个（或多个）线程上进行相关运行操作。

在IO的堵塞后无脑调用线程下。NIO是在准备完成时，才被selector选择分配到一个或者多个线程上传输并被复制到内核地址空间中，由于数据已准备完成或者已就绪，内核就无须被堵塞。

二.Selector（选择器）

也称多路复用器，多条channel复用selector。channe通过注册到selector ，使selector对channel进行监听，

　　实现尽可能少的线程管理多个连接。减少了 线程的使用，降低了因为线程的切换引起的不必要额资源浪费和多余的开销。

　　也是网络传输非堵塞的核心组件。

三.Selector的使用

分为客户端和服务端两部分：

先实现客户端吧：

　　流程： 获取通道绑定主机端口 --> 切换非堵塞状态  --> 开辟buffer容量  -->  将当前时间作为数据写入buffer待传  --> 切换读写方式flip()  --> 写入通道 -->清空并关闭

  /*
     * 客户端发送数据 通过channel通道
     * */
     @Test
     public void Client() throws IOException {

         //获取channel通道   并设置主机号和端口号
         SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",8080));

         //因为使用非阻塞NIO  所以必须切换为非阻塞
         socketChannel.configureBlocking(false);   //默认为true 需要改为非堵塞的

         //开辟缓冲区进行存储数据
         ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

         //准备工作就绪后，准备发送数据给服务端
         //打印当前日期转为Byte数据传出
         byteBuffer.put(new Date().toString().getBytes());
         //切换读写模式
         byteBuffer.flip();
         //写入通道
         socketChannel.write(byteBuffer);
         //完毕时，清除缓冲区内容
         byteBuffer.clear();

     //====================
         //关闭相关流
         socketChannel.close();

     }

在获取当前时间是用的new Date（）；还可以使用java8的获取时间的方法。

LocalDateTime.now().toString().getBytes()  //转为Byte字节

因为是网络传输的心形式，所以在获取channel时，使用SocketChannel.open方法。实现方法：

   public static SocketChannel open(SocketAddress remote)
         throws IOException
     {
         SocketChannel sc = open();
         try {
             sc.connect(remote);   //打开一个新的channel时，绑定连接到主机和端口上
         } catch (Throwable x) {
             try {
                 sc.close();  //异常时关闭连接
             } catch (Throwable suppressed) {
                 x.addSuppressed(suppressed);
             }
             throw x;
         }
         assert sc.isConnected();
         return sc;
     }

new InetSocketAddress实例创建主机和端口。

   */
    public InetSocketAddress(String hostname, int port) {
        checkHost(hostname);    //检查主机号是否为空 为空返回异常。
        InetAddress addr = null;
        String host = null;
        try {
            addr = InetAddress.getByName(hostname);
        } catch(UnknownHostException e) {
            host = hostname;
        }
        holder = new InetSocketAddressHolder(host, addr, checkPort(port));  //检查端口。
    }

//检查端口方法　　

private static int checkPort(int port) {
    if (port < 0 || port > 0xFFFF)
        throw new IllegalArgumentException("port out of range:" + port);
    return port;
}

//检查主机号方法
private static String checkHost(String hostname) {
    if (hostname == null)
        throw new IllegalArgumentException("hostname can't be null");
    return hostname;
}

服务端：

　　流程：使用ServerSocketChannel 的方法获取服务端额channel  --> 切换为堵塞状态 --> 为buffer分配容量 --> 绑定端口号 --> 获取selector选择器 --> channel注册进选择器中，并进行监听 -->  选择器进行轮询，进行下一步读写操作。

  /*
     * 服务端接收客户端传来的数据
     * */
     @Test
     public void server() throws IOException {

         //获取channel通道
         ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
         //切换为非堵塞状态
         serverSocketChannel.configureBlocking(false);
         //分配服务端的缓冲区
         ByteBuffer serverByteBuffer = ByteBuffer.allocate(1024);
         //将客户端的InetSocketAddress绑定到通道，不绑定 不统一将获取不到数据
         serverSocketChannel.bind(new InetSocketAddress(8080));
         //获取选择器
         Selector selector = Selector.open();
         //将通道注册到选择器中,并且制定监听方式
         serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
         //进行轮询选择器上就绪成功的事件  当存在就绪成功的及进行下一步
         while (selector.select() > 0){
             //对已存在的就绪事件进行迭代
             Iterator<SelectionKey> selectionKeyIterator = selector.selectedKeys().iterator();

             //有元素就进行下一步
             while (selectionKeyIterator.hasNext()){
                 //获取到就绪事件
                 SelectionKey next = selectionKeyIterator.next();

                 //对获取到的就绪事件判断是何种类型
                 if (next.isAcceptable()){

                     //获取连接
                     SocketChannel accept = serverSocketChannel.accept();

                     //将获取到的连接切换为非堵塞模式
                     accept.configureBlocking(false);

                     //将获取到的链接 注册金selector
                     accept.register(selector,SelectionKey.OP_READ);

                     //判断是否准备好读
                 }else if (next.isReadable()){

                     //获取已就绪的通道
                     SocketChannel channel = (SocketChannel) next.channel();

                     //分配缓冲区
                     ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

                     //读取数据
                     int length = 0 ;
                     while ((length = channel.read(byteBuffer)) > 0){
                         byteBuffer.flip();
                         System.out.println(new String(byteBuffer.array(),0,length));
                         byteBuffer.clear();
                     }

                 }

                 //完成传输需要取消选择键，防止下次出问题
                 selectionKeyIterator.remove();

             }
         }

     }

如何获取选择器？

Selector selector = Selector.open();

实现过程：

 public static Selector open() throws IOException {
        return SelectorProvider.provider().openSelector();
    }

//首先进入此方法判断是否存在选择器
 public static SelectorProvider provider() {
        synchronized (lock) {
            if (provider != null)  //第一次为false
                return provider;
            return AccessController.doPrivileged(
                new PrivilegedAction<SelectorProvider>() {
                    public SelectorProvider run() {
                            if (loadProviderFromProperty())
                                return provider;
                            if (loadProviderAsService())
                                return provider;
                            provider = sun.nio.ch.DefaultSelectorProvider.create();
                            return provider;
                        }
                    });
        }
    }

//false时 跳入如下方法。

public static ServerSocketChannel open() throws IOException {
    return SelectorProvider.provider().openServerSocketChannel();
}

随后将获取到的通道注册到获取到的选择器中，在注册时给定监听方式：

 serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);  //可多选监听操作项

selectionKey中定义了四个可操作项：

• OP_READ  可读就绪

• OP_WRITE  可写就绪

• OP_CONNECT  连接就绪

• OP_ACCEPT  接收就绪

迭代key中已就绪的元素。

Iterator<SelectionKey> selectionKeyIterator = selector.selectedKeys().iterator();

获取到当前就绪事件丛迭代器中获取。

selectionKeyIterator.next()

selectionKey包含四个方法：

• isReadable（）：测试此选择键是否可读

• isWritable（）：测试此选择键是否可写

• isConnectable（）：测试此选择键是否完成

• isAcceptable（）：测试此选择键是否可以接受一个新的连接

通过这些相应的方法，单独判断是否可以读写，和进行操作。

最后取消选择键，防止下次获取出现异常情况。（第一次判断可能会为true）

selectionKeyIterator.remove();

四.附加

在上面的例子中，把客户端的代码进行稍微改写一下，使之能够无限输入，并通过传输打印在服务端中。

public static void main(String[] args) throws IOException {
        //获取channel通道   并设置主机号和端口号
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",8080));

        //因为使用非阻塞NIO  所以必须切换为非阻塞
        socketChannel.configureBlocking(false);

        //开辟缓冲区进行存储数据
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        //附加输入：
        Scanner scanner = new Scanner(System.in);
        //通过控制台键入数据
        while (scanner.hasNext()){
            String str = scanner.next();
            //准备工作就绪后，准备发送数据给服务端
            //打印当前日期转为Byte数据传出
            byteBuffer.put((new Date().toString()+":--->"+str).getBytes());
            //切换读写模式
            byteBuffer.flip();
            //写入通道
            socketChannel.write(byteBuffer);
            //完毕时，清除缓冲区内容
            byteBuffer.clear();
        }

    }

由于扫描流（scanner）不能用于测试类，所以在main方法下进行测试：

每次输入的内容都会被转为Byte字节进行传输。

客户端输入结果：

服务端输出结果：

每输入一次便传输一次。

//完成传输需要取消选择键，防止下次出问题
selectionKeyIterator.remove();