NioEventLoop源码分析

NioEventLoop源码分析

在Netty开发中，一般异步IO事件处理采用NioEventLoopGroup作为线程池，而NioEventLoop为线程池中单个线程，作为系统任务执行单元。接下来将从源码分析Netty是如何处理任务的。

NioEventLoop线程执行入口为其run()方法，其核心业务流程为：
1. select(wakenUp.getAndSet(false));轮询IO事件
2. processSelectedKeys();处理IO事件
3. runAllTasks();处理任务队列

---

1.1 轮询IO事件

首先来看看轮询IO事件，其调用NioEventLoop中void select(boolean)方法；在void select(boolean)，首先计算定时截至时间，在定时超时截至时间之后50ms，依旧没有select()操作，则selectNow()之后跳出循环。

int selectCnt = 0;//统计for循环次数
long currentTimeNanos = System.nanoTime();//当前系统时间
long selectDeadLineNanos = currentTimeNanos + delayNanos(currentTimeNanos);//任务截止时间
for (;;) {
       long timeoutMillis = (selectDeadLineNanos - currentTimeNanos + 500000L) / 1000000L;               
if (timeoutMillis <= 0) {//超出截至时间50ms
            if (selectCnt == 0) {;//循环中还没有发生任何select操作
                  selector.selectNow();    
            selectCnt = 1;
            }
            break;//select之后立即返回
}
…
}

接着判断是否有任务到来，或任务被唤醒，即刻执行selectNow()并返回。

if (hasTasks() && wakenUp.compareAndSet(false, true)) {
                    selector.selectNow();
                    selectCnt = 1;
                    break；    }

在既没有达到定时任务截至时间，没有任务，且没有唤醒情形下执行selector.select(timeoutMillis);并将计数selectCnt+1；
执行select(timeoutMillis)再次判断当前状态，检查是否需要退出。

if (selectedKeys != 0 || oldWakenUp || wakenUp.get() || hasTasks() || hasScheduledTasks()) {
                    // - Selected something,//产生IO事件
                    // - waken up by user, or//用户唤醒
                    // - the task queue has a pending task.//taskqueue添加任务
                    // - a scheduled task is ready for processing//定时任务就绪
                    break;
}
                if (Thread.interrupted()) {
                     …
                    selectCnt = 1;
                    break;
                }

接下来解决NIO epoll模型下 selctor状态异常导致cpu负载100%的bug。
在Netty中，死循环select()执行操作时，系统给定一个默认select()有效时间，在反复循环过程中，每次循环时间小于系统给定的有效时间且循环次数到达512时，系统任务进入到epool bug中，接着就进行selector重建。

long time = System.nanoTime();
                if (time - TimeUnit.MILLISECONDS.toNanos(timeoutMillis) >= currentTimeNanos) {
           // TimeUnit.MILLISECONDS.toNanos(timeoutMillis)被认为是一次有效的select()操作
                    selectCnt = 1;//操作有效将selectCnt重置
                } else if (SELECTOR_AUTO_REBUILD_THRESHOLD > 0 &&
                        selectCnt >= SELECTOR_AUTO_REBUILD_THRESHOLD) {//当无效循环次数达到阈值512时；
                    rebuildSelector();//重建selector
                    selector = this.selector;
                    selector.selectNow();
                    selectCnt = 1;
                    break;
                }
// SELECTOR_AUTO_REBUILD_THRESHOLD为设置上限无效循环次数

重建selector核心代码,其将原selector有效key及key.attachment()转移只新建的selector上。

private void rebuildSelector0() {
        final Selector oldSelector = selector;
        final SelectorTuple newSelectorTuple;
        …
        newSelectorTuple = openSelector();
        …
        for (SelectionKey key: oldSelector.keys()) {
            Object a = key.attachment();
            try {
                if (!key.isValid() || key.channel().keyFor(newSelectorTuple.unwrappedSelector) != null) {
                    continue;
                }
                int interestOps = key.interestOps();
                key.cancel();
                SelectionKey newKey = key.channel().register(newSelectorTuple.unwrappedSelector, interestOps, a);
                if (a instanceof AbstractNioChannel) {
                    // Update SelectionKey
                    ((AbstractNioChannel) a).selectionKey = newKey;
                }
         …    
       selector = newSelectorTuple.selector

if (ioRatio == 100) {
                    try {
                        processSelectedKeys();
                    } finally {
                        // Ensure we always run tasks.
                        runAllTasks();
                    }
                } else {
                    final long ioStartTime = System.nanoTime();
                    try {
                        processSelectedKeys();
                    } finally {
                        // Ensure we always run tasks.
                        final long ioTime = System.nanoTime() - ioStartTime;
                        runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
                    }
                }

NioEventLoop主要执行IO时间及定时任务，但是Netty作为高并发IO框架，遵循以优先处理IO任务的原则，ioRatio负载去设置定时任务的执行时间，默认iRatio= 50（及IO时间与任务时间相等）

小结
在轮询IO事件过程中，先判断是否需要退出IO执行流程，或执行轮询IO事件按，并且解决了Epoll bug。

1.2 处理IO事件

在分析处理IO事件之前，先来说说netty在处理IO事件之前所做的优化。

private SelectorTuple openSelector() {
        final Selector unwrappedSelector;
        …
            unwrappedSelector = provider.openSelector();
       …
        if (DISABLE_KEYSET_OPTIMIZATION) { 
            return new SelectorTuple(unwrappedSelector);
        }
//默认开启优化
…
        final SelectedSelectionKeySet selectedKeySet = new SelectedSelectionKeySet();
        Object maybeSelectorImplClass = AccessController.doPrivileged(new PrivilegedAction