7. 彤哥说netty系列之Java NIO核心组件之Selector

时间  2020-01-05
标签 netty 系列 java nio 核心 组件 selector 栏目 Netty 繁體版
原文   原文链接

<p align="right">——日拱一卒，不期而至！</p>java

nio

你好，我是彤哥，本篇是netty系列的第七篇。编程

简介

上一章咱们一块儿学习了Java NIO的核心组件Buffer，它一般跟Channel一块儿使用，可是它们在网络IO中又该如何使用呢，今天咱们将一块儿学习另外一个NIO核心组件——Selector，没有它能够说就干不起来网络IO。数组

概念

咱们先来看两段Selector的注释，见类java.nio.channels.Selector。服务器

注释I

> A multiplexor of {@link SelectableChannel} objects.网络

它是SelectableChannel对象的多路复用器，从这里咱们也能够知道Java NIO其实是多路复用IO。架构

SelectableChannel有几个子类，你会很是熟悉：socket

  • DatagramChannel，UDP协议链接
  • SocketChannel，TCP协议链接
  • ServerSocketChannel，专门处理TCP协议Accept事件

咱们有必要复习一下多路复用IO的流程：ide

multiplexing-io

第一阶段经过select去轮询检查有没有链接准备好数据，第二阶段把数据从内核空间拷贝到用户空间。学习

在Java中，就是经过Selector这个多路复用器来实现第一阶段的。ui

注释II

> A selector may be created by invoking the {@link #open open} method of this class, which will use the system's default {@link java.nio.channels.spi.SelectorProvider selector provider} to create a new selector. A selector may also be created by invoking the {@link java.nio.channels.spi.SelectorProvider#openSelector openSelector} method of a custom selector provider. A selector remains open until it is closed via its {@link #close close} method.

Selector能够经过它本身的open()方法建立，它将经过默认的java.nio.channels.spi.SelectorProvider类建立一个新的Selector。也能够经过实现java.nio.channels.spi.SelectorProvider类的抽象方法openSelector()来自定义实现一个Selector。Selector一旦建立将会一直处于open状态直到调用了close()方法为止。

那么，默认使用的Selector到底是哪一个呢？

经过跟踪源码：

&gt; java.nio.channels.Selector#open()
  1&gt; java.nio.channels.spi.SelectorProvider#provider()
    1.1&gt; sun.nio.ch.DefaultSelectorProvider#create() // 返回WindowsSelectorProvider
  2&gt; sun.nio.ch.WindowsSelectorProvider#openSelector() // 返回WindowsSelectorImpl

能够看到，在Windows平台下，默认实现的Provider是WindowsSelectorProvider，它的openSelector()方法返回的是WindowsSelectorImpl，它就是Windows平台默认的Selector实现。

为何要提到在Windows平台呢，难道在Linux下面实现不同？

是滴，由于网络IO是跟操做系统息息相关的，不一样的操做系统的实现可能都不同，Linux下面JDK的实现彻底不同，那么咱们为何没有感知到呢？个人代码在Windows下面写的，拿到Linux下面不是同样运行？那是Java虚拟机（或者说Java运行时环境）帮咱们把这个事干了，它屏蔽了跟操做系统相关的细节，这也是Java代码能够“Write Once, Run Anywhere”的精髓所在。

Selector与Channel的关系

上面咱们说了selector是多路复用器，它是在网络IO的第一阶段用来轮询检查有没有链接准备好数据的，那么它和Channel是什么关系呢？

nio

Selector经过不断轮询的方式同时监听多个Channel的事件，注意，这里是同时监听，一旦有Channel准备好了，它就会返回这些准备好了的Channel，交给处理线程去处理。

因此，在NIO编程中，经过Selector咱们就实现了一个线程同时处理多个链接请求的目标，也能够必定程序下降服务器资源的消耗。

基本用法

建立Selector

经过调用Selector.open()方法是咱们经常使用的方式：

Selector selector = Selector.open();

固然，也能够经过实现java.nio.channels.spi.SelectorProvider.openSelector()抽象方法自定义一个Selector。

将Channel注册到Selector上

为了将Channel跟Selector绑定在一块儿，须要将Channel注册到Selector上，调用Channel的register()方法便可：

channel.configureBlocking(false);

SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

Channel必须是非阻塞模式才能注册到Selector上，因此，没法将一个FileChannel注册到Selector，由于FileChannel没有所谓的阻塞仍是非阻塞模式，本文来源于工从号彤哥读源码。

注册的时候第二个参数传入的是监听的事件，一共有四种事件：

  • Connect
  • Accept
  • Read
  • Write

当Channel触发了某个事件，一般也叫做那个事件就绪了。好比，数据准备好能够读取了就叫做读就绪了，一样地，还有写就绪、链接就绪、接受就绪，固然后面两个不常听到。

在Java中，这四种监听事件是定义在SelectionKey中的：

  • SelectionKey.OP_READ，值为 1 << 0 = 0000 0001
  • SelectionKey.OP_WRITE，值 为 1 << 2 = 0000 0100
  • SelectionKey.OP_CONNECT，值为 1 << 3 = 0000 1000
  • SelectionKey.OP_ACCEPT，值为 1 << 4 = 0001 0000

因此，也能够经过位或命令监听多个感兴趣的事件：

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

SelectionKey

正如上面所看到的，Channel注册到Selector后返回的是一个SelectionKey，因此SelectionKey又能够看做是Channel和Selector之间的一座桥梁，把二者绑定在了一块儿。

SelectionKey具备如下几个重要属性：

  • interest set，感兴趣的事件集
  • ready set，就绪的事件集
  • 保存着的Channel
  • 保存着的Selector
  • attached object，附件

interest set

里面保存了注册Channel到Selector时传入的第二个参数，即感兴趣的事件集。

int interestSet = selectionKey.interestOps();

boolean isInterestedInAccept  = interestSet &amp; SelectionKey.OP_ACCEPT;
boolean isInterestedInConnect = interestSet &amp; SelectionKey.OP_CONNECT;
boolean isInterestedInRead    = interestSet &amp; SelectionKey.OP_READ;
boolean isInterestedInWrite   = interestSet &amp; SelectionKey.OP_WRITE;

能够经过位与运算查看是否注册了相应的事件。

ready set

里面保存了就绪了的事件集。

int readySet = selectionKey.readyOps();
selectionKey.isAcceptable();
selectionKey.isConnectable();
selectionKey.isReadable();
selectionKey.isWritable();

能够经过readyOps()方法获取全部就绪了的事件，也能够经过isXxxable()方法检查某个事件是否就绪。

保存的Channel和Selector

Channel  channel  = selectionKey.channel();

Selector selector = selectionKey.selector();

经过channel()和selector()方法能够获取绑定的Channel和Selector。

attachment

能够调用attach(obj)方法绑定一个对象到SelectionKey上，并在后面须要用到的时候经过attachment()方法取出绑定的对象，也能够翻译为附件，它能够看做是数据传递的一种媒介，跟ThreadLocal有点相似，在前面绑定数据，在后面使用。

selectionKey.attach(theObject);

Object attachedObj = selectionKey.attachment();

固然，也能够在注册Channel到Selector的时候就绑定附件：

SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject);

Selector.select()

一旦将一个或多个Channel注册到Selector上了，咱们就能够调用它的select()方法了，它会返回注册时感兴趣的事件中就绪的事件，本文来源于工从号彤哥读源码。

select()方法有三种变体：

  • select()，无参数，阻塞直到某个Channel有就绪的事件了才返回（固然是咱们注册的感兴趣的事件）
  • select(timeout)，带超时，阻塞直到某个Channel有就绪的事件了，或者超时了才返回
  • selectNow()，当即返回，不会阻塞，无论有没有就绪的Channel都当即返回

select()的返回值为int类型，表示两次select()之间就绪的Channel，即便上一次调用select()时返回的就绪Channel没有被处理，下一次调用select()也不会再返回上一次就绪的Channel。好比，第一次调用select()返回了一个就绪的Channel，可是没有处理它，第二次调用select()时又有一个Channel就绪了，那也只会返回1，而不是2。

Selector.selectedKeys()

一旦调用select()方法返回了有就绪的Channel，咱们就可使用selectedKeys()方法来获取就绪的Channel了。

Set<selectionkey> selectedKeys = selector.selectedKeys();

而后，就能够遍历这些SelectionKey来查看感兴趣的事件是否就绪了：

Set<selectionkey> selectedKeys = selector.selectedKeys();

Iterator<selectionkey> keyIterator = selectedKeys.iterator();

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

    if(key.isAcceptable()) {
        // a connection was accepted by a ServerSocketChannel.

    } else if (key.isConnectable()) {
        // a connection was established with a remote server.

    } else if (key.isReadable()) {
        // a channel is ready for reading

    } else if (key.isWritable()) {
        // a channel is ready for writing
    }

    keyIterator.remove();
}

最后，必定要记得调用keyIterator.remove();移除已经处理的SelectionKey。

Selector.wakeup()

前面咱们说了调用select()方法时，调用者线程会进入阻塞状态，直到有就绪的Channel才会返回。其实也不必定，wakeup()就是用来破坏规则的，能够在另一个线程调用wakeup()方法强行唤醒这个阻塞的线程，这样select()方法也会当即返回。

若是调用wakeup()时并无线程阻塞在select()上，那么，下一次调用select()将当即返回，不会进入阻塞状态。这跟LockSupport.unpark()方法是比较相似的。

Selector.close()

调用close()方法将会关闭Selector，同时也会将关联的SelectionKey失效，但不会关闭Channel。

举个栗子

nio

public class EchoServer {
    public static void main(String[] args) throws IOException {
        // 建立一个Selector
        Selector selector = Selector.open();
        // 建立ServerSocketChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        // 绑定8080端口
        serverSocketChannel.bind(new InetSocketAddress(8080));
        // 设置为非阻塞模式，本文来源于工从号彤哥读源码
        serverSocketChannel.configureBlocking(false);
        // 将Channel注册到selector上，并注册Accept事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {
            // 阻塞在select上
            selector.select();

            // 若是使用的是select(timeout)或selectNow()须要判断返回值是否大于0

            // 有就绪的Channel
            Set<selectionkey> selectionKeys = selector.selectedKeys();
            // 遍历selectKeys
            Iterator<selectionkey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {
                SelectionKey selectionKey = iterator.next();
                // 若是是accept事件
                if (selectionKey.isAcceptable()) {
                    // 强制转换为ServerSocketChannel
                    ServerSocketChannel ssc = (ServerSocketChannel) selectionKey.channel();
                    SocketChannel socketChannel = ssc.accept();
                    System.out.println("accept new conn: " + socketChannel.getRemoteAddress());
                    socketChannel.configureBlocking(false);
                    // 将SocketChannel注册到Selector上，并注册读事件
                    socketChannel.register(selector, SelectionKey.OP_READ);
                } else if (selectionKey.isReadable()) {
                    // 若是是读取事件
                    // 强制转换为SocketChannel
                    SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                    // 建立Buffer用于读取数据
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    // 将数据读入到buffer中
                    int length = socketChannel.read(buffer);
                    if (length &gt; 0) {
                        buffer.flip();
                        byte[] bytes = new byte[buffer.remaining()];
                        // 将数据读入到byte数组中
                        buffer.get(bytes);

                        // 换行符会跟着消息一块儿传过来
                        String content = new String(bytes, "UTF-8").replace("\r\n", "");
                        if (content.equalsIgnoreCase("quit")) {
                            selectionKey.cancel();
                            socketChannel.close();
                        } else {
                            System.out.println("receive msg: " + content);
                        }
                    }
                }
                iterator.remove();
            }
        }
    }
}

总结

今天咱们学习了Java NIO核心组件Selector，到这里，NIO的三个最重要的核心组件咱们就学习完毕了，说实话，NIO这块最重要的仍是思惟的问题，时刻记着在NIO中一个线程是能够处理多个链接的。

看着Java原生NIO实现网络编程彷佛也没什么困难的吗？那么为何还要有Netty呢？下一章咱们将正式进入Netty的学习之中，咱们将在其中寻找答案。

最后，也欢迎来个人工从号彤哥读源码系统地学习源码&架构的知识。

nio</selectionkey></selectionkey></selectionkey></selectionkey></selectionkey>

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程