04 | 事件调度层：为什么 EventLoop 是 Netty 的精髓？

1、单线程模型

略…

2、多线程模型

略…

3、主从多线程模型

略…

4、Netty EventLoop 实现原理

4.1、EventLoop 是什么

每当事件发生时，应用程序都会将产生的事件放入事件队列当中，然后 EventLoop 会轮询从队列中取出事件执行或者将事件分发给相应的事件监听者执行。

事件执行的方式通常分为立即执行、延后执行、定期执行几种。

4.2、Netty 如何实现 EventLoop

在 Netty 中 EventLoop 可以理解为 Reactor 线程模型的事件处理引擎.

每个 EventLoop 线程都维护一个 Selector 选择器和任务队列 taskQueue。它主要负责处理 I/O 事件、普通任务和定时任务。

EventLoop 
    |-selector:Selector 
    |-taskQueue:Queue<Runnable>

Netty 中推荐使用 NioEventLoop 作为实现类

protected void run() {
    for (;;) {
        try {
            try {
                switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {
                case SelectStrategy.CONTINUE:
                    continue;
                case SelectStrategy.BUSY_WAIT:
                case SelectStrategy.SELECT:
                    select(wakenUp.getAndSet(false)); // 轮询 I/O 事件
                    if (wakenUp.get()) {
                        selector.wakeup();
                    }
                default:
                }
            } catch (IOException e) {
                rebuildSelector0();
                handleLoopException(e);
                continue;
            }
            cancelledKeys = 0;
            needsToSelectAgain = false;
            final int ioRatio = this.ioRatio;
            if (ioRatio == 100) {
                try {
                    processSelectedKeys(); // 处理 I/O 事件
                } finally {
                    runAllTasks(); // 处理所有任务
                }
            } else {
                final long ioStartTime = System.nanoTime();
                try {
                    processSelectedKeys(); // 处理 I/O 事件
                } finally {
                    final long ioTime = System.nanoTime() - ioStartTime;
                    runAllTasks(ioTime * (100 - ioRatio) / ioRatio); // 处理完 I/O 事件，再处理异步任务队列
                }
            }
        } catch (Throwable t) {
            handleLoopException(t);
        }
        try {
            if (isShuttingDown()) {
                closeAll();
                if (confirmShutdown()) {
                    return;
                }
            }
        } catch (Throwable t) {
            handleLoopException(t);
        }
    }
}

4.3、事件处理机制

EventLoop 的事件流转图

NioEventLoop 的事件处理机制采用的是无锁串行化的设计思路。

Boss EventLoopGroup 负责监听客户端的 Accept 事件 ->

事件触发时，将事件注册至 Worker EventLoopGroup 中的一个 NioEventLoop，每新建一个 Channel， 只选择一个 NioEventLoop 与其绑定

Channel 生命周期的所有事件处理都是线程独立

NioEventLoop 完成数据读取后，会调用绑定的 ChannelPipeline 进行事件传播，ChannelPipeline 也是线程安全的

NioEventLoop 无锁串行化使系统吞吐量达到最大化，降低了用户开发业务逻辑的难度（不需要关心线程安全问题）。

缺陷就是不能执行时间过长的 I/O 操作，一旦某个 I/O 事件发生阻塞，那么后续的所有 I/O 事件都无法执行，甚至造成事件积压。

Boss EventLoopGroup
    |-NioEventLoop 负责监听客户端的 Accept 事件
    
WorkerEventLoopGroup
    |-NioEventLoop

臭名昭著的 JDK epoll 空轮询Bug： 在 JDK 中， Epoll 的实现是存在漏洞的，即使 Selector 轮询的事件列表为空，NIO 线程一样可以被唤醒，导致 CPU 100% 占用

Netty 并没有从根源上解决该问题，而是巧妙地规避了这个问题。

// io.netty.channel.nio.NioEventLoop#select
private void select(boolean oldWakenUp) throws IOException {
	// 每次执行 Select 操作之前记录当前时间
	long currentTimeNanos = System.nanoTime();
	....
	long time = System.nanoTime();
	// 如果事件轮询的持续时间大于等于 timeoutMillis，阻塞时间达到预期正常
	// 否则表明阻塞时间并未达到预期，可能触发了空轮询的 Bug。
	if (time - TimeUnit.MILLISECONDS.toNanos(timeoutMillis) >= currentTimeNanos) {
	    selectCnt = 1;
	  // 达到SELECTOR_AUTO_REBUILD_THRESHOLD默认值512，会触发重建 Selector 
	} else if (SELECTOR_AUTO_REBUILD_THRESHOLD > 0 &&
	        selectCnt >= SELECTOR_AUTO_REBUILD_THRESHOLD) {
	    rebuildSelector();
        selector = this.selector;
        selector.selectNow();
	    selectCnt = 1;
	    break;
	}
}

4.4、任务处理机制

NioEventLoop 不仅负责处理 I/O 事件，还要兼顾执行任务队列中的任务。

任务队列遵循 FIFO 规则，可以保证任务执行的公平性。

NioEventLoop 处理的任务类型可以分为三类：

1、普通任务

通过 NioEventLoop 的 execute() 方法向任务队列 taskQueue 中添加任务。

2、定时任务

通过调用 NioEventLoop 的 schedule() 方法向定时任务队列 scheduledTaskQueue 添加一个定时任务，用于周期性执行该任务。

3、尾部队列任务

tailTasks 相比于普通任务队列优先级较低，在每次执行完 taskQueue 中任务后会去获取尾部队列中任务执行。

// io.netty.util.concurrent.SingleThreadEventExecutor#runAllTasks(long)
protected boolean runAllTasks(long timeoutNanos) {
	// 1. 合并定时任务到普通任务队列
    fetchFromScheduledTaskQueue();
    // 2. 从普通任务队列中取出任务
    Runnable task = pollTask();
    if (task == null) {
        afterRunningAllTasks();
        return false;
    }
	// 3. 计算任务处理的超时时间
    final long deadline = ScheduledFutureTask.nanoTime() + timeoutNanos;
    long runTasks = 0;
    long lastExecutionTime;
    for (;;) {
    	// 4. 安全执行任务
        safeExecute(task);

        runTasks ++;

        // Check timeout every 64 tasks because nanoTime() is relatively expensive.
        // XXX: Hard-coded value - will make it configurable if it is really a problem.
        // 5. 每执行 64 个任务检查一下是否超时
        if ((runTasks & 0x3F) == 0) {
            lastExecutionTime = ScheduledFutureTask.nanoTime();
            if (lastExecutionTime >= deadline) {
                break;
            }
        }

        task = pollTask();
        if (task == null) {
            lastExecutionTime = ScheduledFutureTask.nanoTime();
            break;
        }
    }
    // 6. 收尾工作
    afterRunningAllTasks();
    this.lastExecutionTime = lastExecutionTime;
    return true;
}

4.5、EventLoop 最佳实践

在日常开发中用好 EventLoop 至关重要，这里结合实际工作中的经验给出一些 EventLoop 的最佳实践方案。

1、网络连接建立过程中三次握手、安全认证的过程会消耗不少时间。这里建议采用 Boss 和 Worker 两个 EventLoopGroup，有助于分担 Reactor 线程的压力。
2、由于 Reactor 线程模式适合处理耗时短的任务场景，对于耗时较长的 ChannelHandler 可以考虑维护一个业务线程池，将编解码后的数据封装成 Task 进行异步处理，避免 ChannelHandler 阻塞而造成 EventLoop 不可用。

3、如果业务逻辑执行时间较短，建议直接在 ChannelHandler 中执行。例如编解码操作，这样可以避免过度设计而造成架构的复杂性。

4、不宜设计过多的 ChannelHandler。对于系统性能和可维护性都会存在问题，在设计业务架构的时候，需要明确业务分层和 Netty 分层之间的界限。不要一味地将业务逻辑都添加到 ChannelHandler 中。