EventLoop和EventLoopGroup

        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
                .option(ChannelOption.SO_BACKLOG, 100)
                .handler(new LoggingHandler(LogLevel.INFO))
                .childHandler(new ChannelInitializer() {
                    @Override
                    public void initChannel(Channel ch)throws IOException{
                        ch.pipeline().addLast(new NettyMessageDecoder(1024 * 1024, 4, 4));
                        ch.pipeline().addLast(new NettyMessageEncoder());
                        ch.pipeline().addLast("readTimeoutHandler",new ReadTimeoutHandler(50));
                        ch.pipeline().addLast(new LoginAuthRespHandler());
                        ch.pipeline().addLast("HeartBeatHandler",new HeartBeatRespHandler());
                    }
                });

        // 绑定端口，同步等待成功
        b.bind(NettyConstant.REMOTEIP, NettyConstant.PORT).sync();

    Selector selector;
    private SelectedSelectionKeySet selectedKeys;

    private final SelectorProvider provider;

    NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider) {
        super(parent, executor, false);
        if (selectorProvider == null) {
            throw new NullPointerException("selectorProvider");
        }
        provider = selectorProvider;
        selector = openSelector();
    }

    private Selector openSelector() {
        final Selector selector;
        try {
            //通过provider.openSelector()创建并打开多路复用器
            selector = provider.openSelector();
        } catch (IOException e) {
            throw new ChannelException("failed to open a new selector", e);
        }
        //如果没有开启selectedKeys优化开关，就立即返回。
        if (DISABLE_KEYSET_OPTIMIZATION) {
            return selector;
        }
        //如果开启了优化开关，需要通过反射的方式从Selector实例中获取selectedKeys和publicSelectedKeys，
        //将上述两个成员变量设置为可写，通过反射的方式使用Netty构造的selectedKeys包装类selectedKeySet将原JDK的selectedKeys替换掉。
        try {
            SelectedSelectionKeySet selectedKeySet = new SelectedSelectionKeySet();

            Class<?> selectorImplClass =
                    Class.forName("sun.nio.ch.SelectorImpl", false, ClassLoader.getSystemClassLoader());

            // Ensure the current selector implementation is what we can instrument.
            if (!selectorImplClass.isAssignableFrom(selector.getClass())) {
                return selector;
            }

            Field selectedKeysField = selectorImplClass.getDeclaredField("selectedKeys");
            Field publicSelectedKeysField = selectorImplClass.getDeclaredField("publicSelectedKeys");

            selectedKeysField.setAccessible(true);
            publicSelectedKeysField.setAccessible(true);

            selectedKeysField.set(selector, selectedKeySet);
            publicSelectedKeysField.set(selector, selectedKeySet);

            selectedKeys = selectedKeySet;
            logger.trace("Instrumented an optimized java.util.Set into: {}", selector);
        } catch (Throwable t) {
            selectedKeys = null;
            logger.trace("Failed to instrument an optimized java.util.Set into: {}", selector, t);
        }

        return selector;
    }

    @Override
    protected void run() {
        //所有的逻辑操作都在for循环体内进行，只有当NioEventLoop接收到退出指令的时候，才退出循环，否则一直执行下去，这也是通用的NIO线程实现方式。
        for (;;) {
            //首先需要将wakenUp还原为false，并将之前的wakeup状态保存到oldWakenUp变量中。
            oldWakenUp = wakenUp.getAndSet(false);
            try {
                //通过hasTasks()方法判断当前的消息队列中是否有消息尚未处理
                if (hasTasks()) {
                    //如果有则调用selectNow()方法立即进行一次select操作，看是否有准备就绪的Channel需要处理。
                    //Selector的selectNow()方法会立即触发Selector的选择操作，如果有准备就绪的Channel，则返回就绪Channel的集合，否则返回0。
                    //选择完成之后，再次判断用户是否调用了Selector的wakeup方法，如果调用，则执行selector.wakeup()操作。
                    selectNow();
                } else {
                    //执行select()方法，由Selector多路复用器轮询，看是否有准备就绪的Channel。
                    //取当前系统的纳秒时间，调用delayNanos()方法计算获得NioEventLoop中定时任务的触发时间。
                    //计算下一个将要触发的定时任务的剩余超时时间，将它转换成毫秒，为超时时间增加0.5毫秒的调整值。
                    //对剩余的超时时间进行判断，如果需要立即执行或者已经超时，则调用selector.selectNow()进行轮询操作，将selectCnt设置为1，并退出当前循环。
                    //将定时任务剩余的超时时间作为参数进行select操作，每完成一次select操作，对select计数器selectCnt加1。
                    //Select操作完成之后，需要对结果进行判断，如果存在下列任意一种情况，则退出当前循环:
                    //if (selectedKeys != 0 || oldWakenUp || wakenUp.get() || hasTasks()) {break}
                    //1.有Channel处于就绪状态，selectedKeys不为0，说明有读写事件需要处理；
                    //2.oldWakenUp为true；
                    //3.系统或者用户调用了wakeup操作，唤醒当前的多路复用器；
                    //4.消息队列中有新的任务需要处理。
                    //如果本次Selector的轮询结果为空，也没有wakeup操作或是新的消息需要处理，则说明是个空轮询.
                    //有可能触发了JDK的epoll bug，它会导致Selector的空轮询，使I/O线程一直处于100%状态。
                    //截止到当前最新的JDK7版本，该bug仍然没有被完全修复。所以Netty需要对该bug进行规避和修正。
                    //该Bug的修复策略如下:
                    //（1）对Selector的select操作周期进行统计；
                    //（2）每完成一次空的select操作进行一次计数；
                    //（3）在某个周期（例如100ms）内如果连续发生N次空轮询，说明触发了JDK NIO的epoll()死循环bug。
                    //监测到Selector处于死循环后，需要通过重建Selector的方式让系统恢复正常,重建步骤如下：
                    //(1)首先通过inEventLoop()方法判断是否是其他线程发起的rebuildSelector，
                    //如果由其他线程发起，为了避免多线程并发操作Selector和其他资源，需要将rebuildSelector封装成Task，
                    //放到NioEventLoop的消息队列中，由NioEventLoop线程负责调用，这样就避免了多线程并发操作导致的线程安全问题。
                    //(2)调用openSelector方法创建并打开新的Selector
                    //(3)通过循环，将原Selector上注册的SocketChannel从旧的Selector上去注册，重新注册到新的Selector上，并将老的Selector关闭。
                    //过销毁旧的、有问题的多路复用器，使用新建的Selector，就可以解决空轮询Selector导致的I/O线程CPU占用100%的问题。
                    select();
                    //判断用户是否调用了Selector的wakeup方法
                    if (wakenUp.get()) {
                        //如果调用，则执行selector.wakeup()操作。
                        selector.wakeup();
                    }
                }

                cancelledKeys = 0;

                final long ioStartTime = System.nanoTime();
                needsToSelectAgain = false;
                //如果轮询到了处于就绪状态的SocketChannel，则需要处理网络I/O事件
                if (selectedKeys != null) {
                    processSelectedKeysOptimized(selectedKeys.flip());
                } else {
                    //由于默认未开启selectedKeys优化功能，所以会进入processSelectedKeysPlain分支执行。
                    //1.对SelectionKey进行保护性判断，如果为空则返回。
                    //2.获取SelectionKey的迭代器进行循环操作，通过迭代器获取SelectionKey和SocketChannel的附件对象，
                    //3.将已选择的选择键从迭代器中删除，防止下次被重复选择和处理
                    //4.对SocketChannel的附件类型进行判读，
                    //如果是AbstractNioChannel类型，说明它是NioServerSocketChannel或者NioSocketChannel，需要进行I/O读写相关的操作
                    //步骤如下：
                    //--首先从NioServerSocketChannel或者NioSocketChannel中获取其内部类Unsafe，判断当前选择键是否可用，
                    //--如果不可用，则调用Unsafe的close方法，释放连接资源。
                    //--如果选择键可用，则继续对网络操作位进行判断,如下：
                    //----如果是读或者连接操作，则调用Unsafe的read方法。此处Unsafe的实现是个多态
                    //对于NioServerSocketChannel，它的读操作就是接收客户端的TCP连接。
                    //对于NioSocketChannel，它的读操作就是从SocketChannel中读取ByteBuffer。
                    //----如果网络操作位为写，则说明有半包消息尚未发送完成，需要继续调用flush方法进行发送
                    //----如果网络操作位为连接状态，则需要对连接结果进行判读,在进行finishConnect判断之前，需要将网络操作位进行修改，注销掉SelectionKey.OP_CONNECT。
                    //如果它是NioTask，则对其进行类型转换，调用processSelectedKey进行处理。由于Netty自身没实现NioTask接口，所以通常情况下系统不会执行该分支，除非用户自行注册该Task到多路复用器。
                    processSelectedKeysPlain(selector.selectedKeys());
                }
                //由于NioEventLoop需要同时处理I/O事件和非I/O任务，为了保证两者都能得到足够的CPU时间被执行，Netty提供了I/O比例供用户定制。
                //如果I/O操作多于定时任务和Task，则可以将I/O比例调大，反之则调小，默认值为50%。
                //Task的执行时间根据本次I/O操作的执行时间计算得来。
                final long ioTime = System.nanoTime() - ioStartTime;
                final int ioRatio = this.ioRatio;//50%
                //处理完I/O事件之后，NioEventLoop需要执行非I/O操作的系统Task和定时任务
                //首先从定时任务消息队列中弹出消息进行处理，如果消息队列为空，则退出循环。
                //根据当前的时间戳进行判断，如果该定时任务已经或者正处于超时状态，则将其加入到执行Task Queue中，同时从延时队列中删除。
                //定时任务如果没有超时，说明本轮循环不需要处理，直接退出即可。
                //执行Task Queue中原有的任务和从延时队列中复制的已经超时或者正处于超时状态的定时任务
                //由于获取系统纳秒时间是个耗时的操作，每次循环都获取当前系统纳秒时间进行超时判断会降低性能。
                //为了提升性能，每执行60次循环判断一次，如果当前系统时间已经到了分配给非I/O操作的超时时间，则退出循环。
                //这是为了防止由于非I/O任务过多导致I/O操作被长时间阻塞。
                runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
                //判断系统是否进入优雅停机状态，如果处于关闭状态。
                if (isShuttingDown()) {
                    //调用closeAll方法，释放资源。遍历获取所有的Channel，调用它的Unsafe.close()方法关闭所有链路，释放线程池、ChannelPipeline和ChannelHandler等资源。
                    closeAll();
                    //并让NioEventLoop线程退出循环，结束运行。
                    if (confirmShutdown()) {
                        break;
                    }
                }
            } catch (Throwable t) {
                logger.warn("Unexpected exception in the selector loop.", t);

                // Prevent possible consecutive immediate failures that lead to
                // excessive CPU consumption.
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // Ignore.
                }
            }
        }
    }