public final class NioEventLoop extends SingleThreadEventLoop {      //绑定 selector     Selector selector;    //优化过的Set集合    private SelectedSelectionKeySet selectedKeys;    //引用全局 SelectorProvider    private final SelectorProvider provider;    ///////////////////////////////////////////    //为true时执行selector.wakeup()    private final AtomicBoolean wakenUp = new AtomicBoolean();    //io任务占时比率     private volatile int ioRatio = 50;    //记录selectionKey撤销次数    private int cancelledKeys;    //处理selector.selectNow() 标志    private boolean needsToSelectAgain;}

    //netty 用到反射加 AccessController技术替换掉 Selector selectedKeySet 字段    private Selector openSelector() {        final Selector selector = provider.openSelector();        final SelectedSelectionKeySet selectedKeySet = new SelectedSelectionKeySet();        Object maybeSelectorImplClass = AccessController.doPrivileged(new PrivilegedAction<Object>() {            @Override            public Object run() {                try {                    return Class.forName(                            "sun.nio.ch.SelectorImpl",                            false,                            PlatformDependent.getSystemClassLoader());                } catch (Throwable cause) {                    return cause;                }            }        });        final Class<?> selectorImplClass = (Class<?>) maybeSelectorImplClass;        Object maybeException = AccessController.doPrivileged(new PrivilegedAction<Object>() {            @Override            public Object run() {                //用到反射技术更改 SelectorImpl 字段                Field selectedKeysField = selectorImplClass.getDeclaredField("selectedKeys");                Field publicSelectedKeysField = selectorImplClass.getDeclaredField("publicSelectedKeys");                selectedKeysField.setAccessible(true);                publicSelectedKeysField.setAccessible(true);                selectedKeysField.set(selector, selectedKeySet);                publicSelectedKeysField.set(selector, selectedKeySet);                return null;            }        });        return selector;    }//重新构建Selector    private void rebuildSelector0() {        final Selector oldSelector = selector;        final Selector newSelector;        if (oldSelector == null) {            return;        }       newSelector = openSelector();        //迁移处理        int nChannels = 0;        for (SelectionKey key: oldSelector.keys()) {            Object a = key.attachment();            try {                //过滤key是否合法 已处理                if (!key.isValid() || key.channel().keyFor(newSelector) != null) {                    continue;                }                int interestOps = key.interestOps();                key.cancel();                SelectionKey newKey = key.channel().register(newSelector, interestOps, a);                if (a instanceof AbstractNioChannel) {                    // channel重新绑定SelectionKey                    ((AbstractNioChannel) a).selectionKey = newKey;                }                nChannels ++;            } catch (Exception e) {                //出错处理 netty认为 socket已关闭                if (a instanceof AbstractNioChannel) {                    AbstractNioChannel ch = (AbstractNioChannel) a;                    ch.unsafe().close(ch.unsafe().voidPromise());                } else {                    @SuppressWarnings("unchecked")                    NioTask<SelectableChannel> task = (NioTask<SelectableChannel>) a;                    invokeChannelUnregistered(task, key, e);                }            }        }        selector = newSelector;        oldSelector.close();     }

final class SelectedSelectionKeySet extends AbstractSet<SelectionKey> {        private SelectionKey[] keysA;        private int keysASize;        private SelectionKey[] keysB;        private int keysBSize;        private boolean isA = true;        SelectedSelectionKeySet() {            keysA = new SelectionKey[1024];            keysB = keysA.clone();        }        @Override        public boolean add(SelectionKey o) {            if (o == null) {                return false;            }            //是A开关即处理A            if (isA) {                int size = keysASize;                keysA[size ++] = o;                keysASize = size;                //双倍扩展容量                if (size == keysA.length) {                    doubleCapacityA();                }            } else {                int size = keysBSize;                keysB[size ++] = o;                keysBSize = size;                if (size == keysB.length) {                    doubleCapacityB();                }            }            return true;        }        private void doubleCapacityA() {            SelectionKey[] newKeysA = new SelectionKey[keysA.length << 1];            System.arraycopy(keysA, 0, newKeysA, 0, keysASize);            keysA = newKeysA;        }        private void doubleCapacityB() {            SelectionKey[] newKeysB = new SelectionKey[keysB.length << 1];            System.arraycopy(keysB, 0, newKeysB, 0, keysBSize);            keysB = newKeysB;        }        //获取keys并切换        SelectionKey[] flip() {            if (isA) {                isA = false;                keysA[keysASize] = null;                keysBSize = 0;                return keysA;            } else {                isA = true;                keysB[keysBSize] = null;                keysASize = 0;                return keysB;            }        }        @Override        public int size() {            return isA?keysASize : keysBSize;        }    }

private void select(boolean oldWakenUp) throws IOException {        Selector selector = this.selector;               int selectCnt = 0;            long currentTimeNanos = System.nanoTime();            //通过delayNanos计算出 select结束时间            long selectDeadLineNanos = currentTimeNanos + delayNanos(currentTimeNanos);            for (;;) {                //计算出超时并转换成毫秒，再加上延时固定0.5毫秒                long timeoutMillis = (selectDeadLineNanos - currentTimeNanos + 500000L) / 1000000L;                if (timeoutMillis <= 0) {                    if (selectCnt == 0) {                        selector.selectNow();                        selectCnt = 1;                    }                    break;                }                //如果有非IO任务，优先等侍selector操作                if (hasTasks() && wakenUp.compareAndSet(false, true)) {                    selector.selectNow();                    selectCnt = 1;                    break;                }                //阻塞当前线程                int selectedKeys = selector.select(timeoutMillis);                selectCnt ++;                //有IO,非IO，计划任务，wakenUp状态认为已完成 select 处理                if (selectedKeys != 0 || oldWakenUp || wakenUp.get() || hasTasks() || hasScheduledTasks()) {                    break;                }                //如果当前线程中断，netty认为关闭了服务，退出处理                if (Thread.interrupted()) {                    selectCnt = 1;                    break;                }                //相当于下面等价,意思是当前时间大于或等于 (selectDeadLineNanos + 0.5毫秒) selectCnt 重置                //currentTimeNanos + (System.nanoTime() -  selectDeadLineNanos - 500000L )   >= currentTimeNanos                //System.nanoTime() -  selectDeadLineNanos - 500000L >= 0                //System.nanoTime() >= selectDeadLineNanos + 500000L                 long time = System.nanoTime();                if (time - TimeUnit.MILLISECONDS.toNanos(timeoutMillis) >= currentTimeNanos) {                    selectCnt = 1;                } else if (SELECTOR_AUTO_REBUILD_THRESHOLD > 0 &&                        selectCnt >= SELECTOR_AUTO_REBUILD_THRESHOLD) {                                        // selectCnt >= SELECTOR_AUTO_REBUILD_THRESHOLD 默认值512，重构selector                    rebuildSelector();                    selector = this.selector;                    selector.selectNow();                    selectCnt = 1;                    break;                }                //刷新当前时间                currentTimeNanos = time;            }       }

//这部分做了代码整理    @Override    protected void run() {        for (;;) {            try {                //检查是否有非IO任务同WAKEUP_TASK任务                if(!hasTasks()){                    continue;                }                //有任务就触发重写的 select                 select(wakenUp.getAndSet(false));                if (wakenUp.get()) {                    selector.wakeup();                }                cancelledKeys = 0;                needsToSelectAgain = false;                final int ioRatio = this.ioRatio;//默认值50                               try {                    final long ioStartTime = System.nanoTime();                    //processSelectedKeys();                    //一般会selectedKeys不会为null做了优化处理                    if (selectedKeys != null) {                        processSelectedKeysOptimized(selectedKeys.flip());                    } else {                        processSelectedKeysPlain(selector.selectedKeys());                    }                } finally {                    //当ioRatio等于100时，百分百执行非IO全部任务                    if (ioRatio == 100) {                        runAllTasks();                    }else{                        final long ioTime = System.nanoTime() - ioStartTime;                        //计算时非IO任务超时时间，公式 = 100 - ioRatio 算出非IO比率再跟IO相比 执行过的IO时间 * (非IO:IO)                        runAllTasks(ioTime * (100 - ioRatio) / ioRatio);                    }                }             } catch (Throwable t) {                //防止过多失败                Thread.sleep(1000);            }                        //处理完任务判断是否结束             try {                if (isShuttingDown()) {                    closeAll();                    if (confirmShutdown()) {                        return;                    }                }            } catch (Throwable t) {                  Thread.sleep(1000);            }        }    }    private void processSelectedKeysOptimized(SelectionKey[] selectedKeys) {        for (int i = 0;; i ++) {            final SelectionKey k = selectedKeys[i];            if (k == null) {                break;            }            //依赖外部逻辑清理            selectedKeys[i] = null;            final Object a = k.attachment();            //处理SelectedKey            if (a instanceof AbstractNioChannel) {                processSelectedKey(k, (AbstractNioChannel) a);            } else {                @SuppressWarnings("unchecked")                NioTask<SelectableChannel> task = (NioTask<SelectableChannel>) a;                processSelectedKey(k, task);            }            //这里用到比较奇怪的处理，应该是个补丁来的。。。             //从资料来源上说：当触发needsToSelectAgain时 channel全是关闭，所以忽略selectedKeys剩余的key，然后再重获取获取selectedKeys            // null out entries in the array to allow to have it GC‘ed once the Channel close            // See https://github.com/netty/netty/issues/2363            if (needsToSelectAgain) {                for (;;) {                    i++;                    if (selectedKeys[i] == null) {                        break;                    }                    selectedKeys[i] = null;                }                selectAgain();                selectedKeys = this.selectedKeys.flip();                i = -1;            }        }    }    private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {        final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();        if (!k.isValid()) {            final EventLoop eventLoop;            try {                eventLoop = ch.eventLoop();            } catch (Throwable ignored) {                return;            }            //这里忽略情况是 在执行 registerd deregistration 时不能关闭，至于前后顺序无需要太多关心，读者可以进去看看            //每个人出现情况不一样，再加上eventLoop不可能为null的，这段代码明显没有经过测试            // Only close ch if ch is still registerd to this EventLoop. ch could have deregistered from the event loop            // and thus the SelectionKey could be cancelled as part of the deregistration process, but the channel is            // still healthy and should not be closed.            // See https://github.com/netty/netty/issues/5125            if (eventLoop != this || eventLoop == null) {                return;            }            unsafe.close(unsafe.voidPromise());            return;        }        try {            int readyOps = k.readyOps();            // 如果出现OP_CONNECT 状态必须先完成Connect 才能触发 read or wirte 操作            if ((readyOps & SelectionKey.OP_CONNECT) != 0) {                //清除SelectionKey.OP_CONNECT状态                int ops = k.interestOps();                ops &= ~SelectionKey.OP_CONNECT;                k.interestOps(ops);                unsafe.finishConnect();            }                        //ByteBuffer 发送出去            if ((readyOps & SelectionKey.OP_WRITE) != 0) {                 ch.unsafe().forceFlush();            }            //netty将OP_READ,OP_ACCEPT 状态统一执行read操作，那netty如何区分 read accept的呢，后面才分析            if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {                unsafe.read();            }        } catch (CancelledKeyException ignored) {            unsafe.close(unsafe.voidPromise());        }    }        //处理任务，失败策略执行注销处理    private static void processSelectedKey(SelectionKey k, NioTask<SelectableChannel> task) {        try {            task.channelReady(k.channel(), k);            if (!k.isValid()) {                 task.channelUnregistered(k.channel(), null);            }        } catch (Exception e) {            k.cancel();            task.channelUnregistered(k.channel(), null);        }      }