上文提到，早期基于线程的网络模型，处理高并发的能力非常差，随着请求数量的增多，必须不断新建线程，随之带来的问题就是服务器资源被占满、上下文切换成本过高以及IO阻塞导致的CPU浪费。
而Netty则使用了经典Reactor模型，并重新进行了封装，包括EventLoop、EventGroup等。
EventLoopGroup
EventLoopGroup是一个接口，继承自线程池EventExecutorGroup，并允许注册channel到自身所持有的EventLoop，同时支持按一定规则获取下一个EventLoop。
EventLoopGroup的具体实现有很多，下面以DefaultEventLoopGroup为例，简述一下我的理解
1.ScheduledExecutorService
JDK接口，一个延迟或定时任务的执行器，其实现类ScheduledThreadPoolExecutor主要是利用了延时队列及设置下次执行时间来实现的，这里不再赘述（可以单独开个专题0.0）
2.EventExecutorGroup
接口，Netty自定义的一个线程池，负责复用EventExecutor和执行任务
3.EventLoopGroup
核心接口，EventLoopGroup继承自EventExecutorGroup，代表他是一个线程池。同时他具备将channel注册到EventExecutorGroup的功能，代表他是一个能够真正处理Channel的特殊线程池
4.MultithreadEventExecutorGroup（AbstractEventExecutorGroup）
抽象类，实现自EventExecutorGroup接口，提供了一个简易线程池的实现，其只有一个抽象方法newChild（创建EventExecutor）供子类实现
protected MultithreadEventExecutorGroup(int nThreads, Executor executor, EventExecutorChooserFactory chooserFactory, Object... args)
4.1 nThreads
private final EventExecutor[] children;
该线程池通过数组存储线程，入参nThreads指定数组大小，并循环调用newChild创建线程。当创建过程中有异常时，会自动调用已创建完成线程的shutdownGracefully方法，进行优雅关闭
for (int i = 0; i < nThreads; i ++) {
boolean success = false;
try {
children[i] = newChild(executor, args);
success = true;
} catch (Exception e) {
// TODO: Think about if this is a good exception type
throw new IllegalStateException("failed to create a child event loop", e);
} finally {
if (!success) {
for (int j = 0; j < i; j ++) {
children[j].shutdownGracefully();
}
for (int j = 0; j < i; j ++) {
EventExecutor e = children[j];
try {
while (!e.isTerminated()) {
e.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
}
} catch (InterruptedException interrupted) {
// Let the caller handle the interruption.
Thread.currentThread().interrupt();
break;
}
}
}
}
}
4.2 EventExecutorChooserFactory
EventExecutorChooserFactory是一个工厂接口，负责创建EventExecutorChooser
其默认实现DefaultEventExecutorChooserFactory会判断当前线程数是否2的n次幂，如果是则返回PowerOfTwoEventExecutorChooser，否则返回GenericEventExecutorChooser
4.3 EventExecutorChooser
private final EventExecutorChooserFactory.EventExecutorChooser chooser;
EventExecutorChooser负责根据一定规则从线程池children数组中取得下一个线程
PowerOfTwoEventExecutorChooser：通过&运算，将超出executors.length的位置为0
public EventExecutor next() {
return executors[idx.getAndIncrement() & executors.length - 1];
}
GenericEventExecutorChooser：通过求余运算，获取有效index
public EventExecutor next() {
return executors[Math.abs(idx.getAndIncrement() % executors.length)];
}
可以看出当线程数是2的n次幂时，Netty通过与运算优化了效率
5.MultithreadEventLoopGroup
抽象类，继承自MultithreadEventExecutorGroup并实现了EventLoopGroup接口，代表此抽象类是一个可以注册并处理channel的线程池
值得关注的是next方法，他把返回值的类型，进一步限定为EventLoop
public EventLoop next() {
return (EventLoop) super.next();
}
6.DefaultEventLoopGroup
MultithreadEventLoopGroup的一个默认实现
其核心就是实现了newChild方法返回一个EventLoop extends EventExecutor实例
protected EventLoop newChild(Executor executor, Object... args) throws Exception {
return new DefaultEventLoop(this, executor);
}
7.总结
说白了EventLoopGroup核心方法，register负责将channel与线程池中某一线程绑定，next负责返回下一个线程供调用方执行任务
EventLoop
EventLoop直译为事件循环，他的职责简单来说就是绑定一个唯一的线程，去执行或调度被分配的任务。
可见一个EventLoop实例可以为多个channel服务，而为了最大化利用资源，Netty使用池化技术将EventLoop放入EventLoopGroup中管理。
EventLoop的具体实现有很多，先看下DefaultEventLoop的类图，会发现他和DefaultEventLoopGroup的类图很像，都继承了EventLoopGroup接口，但其最大的不同是红框所示，他还继承了EventExecutor，下面主要讲一下多出来的这部分到底是干了什么
1.EventExecutor
接口，定义了一个事件执行器，主要方法如下
/**
* 直接返回自身
*/
@Override
EventExecutor next();
/**
* 返回所属线程池
*/
EventExecutorGroup parent();
/**
* 判断当前线程是否是当前EventLoop绑定的线程
*/
boolean inEventLoop();
/**
* 判断传入线程是否是当前EventLoop绑定的线程
*/
boolean inEventLoop(Thread thread);
（还涉及一些Future异步编程的一些东西，太复杂了后续再填坑吧0.0）
2.AbstractScheduledEventExecutor （AbstractEventExecutor）
抽象类，简单定义了一个支持延迟（定时）任务的执行器
//延时队列
PriorityQueue<ScheduledFutureTask<?>> scheduledTaskQueue;
//下一个任务id
long nextTaskId;
重要方法scheduled
private <V> ScheduledFuture<V> schedule(final ScheduledFutureTask<V> task) {
if (inEventLoop()) {
//如果和执行器绑定的线程一致，直接放入延时队列中
scheduleFromEventLoop(task);
} else {
//获取任务最晚执行时间
final long deadlineNanos = task.deadlineNanos();
// task will add itself to scheduled task queue when run if not expired
if (beforeScheduledTaskSubmitted(deadlineNanos)) {
//放入线程池执行
execute(task);
} else {
//与execute类似，但不保证任务会在执行非延迟任务或执行程序关闭之前运行，默认实现只是委托给execute(Runnable)
lazyExecute(task);
// Second hook after scheduling to facilitate race-avoidance
if (afterScheduledTaskSubmitted(deadlineNanos)) {
execute(WAKEUP_TASK);
}
}
}
return task;
}
3.SingleThreadEventExecutor
抽象类，定义了一个单线程顺序执行器
private void execute(Runnable task, boolean immediate) {
boolean inEventLoop = inEventLoop();
//添加到任务队列
addTask(task);
if (!inEventLoop) {
//启动线程
startThread();
//如果线程池已经关闭，调用拒绝方法
if (isShutdown()) {
boolean reject = false;
try {
if (removeTask(task)) {
reject = true;
}
} catch (UnsupportedOperationException e) {
// The task queue does not support removal so the best thing we can do is to just move on and
// hope we will be able to pick-up the task before its completely terminated.
// In worst case we will log on termination.
}
if (reject) {
reject();
}
}
}
//唤醒线程
if (!addTaskWakesUp && immediate) {
wakeup(inEventLoop);
}
}
4.SingleThreadEventLoop
public abstract class SingleThreadEventLoop extends SingleThreadEventExecutor implements EventLoop
EventLoop的抽象基类，负责在单线程中执行所有被提交的任务，同时具有注册和处理channle的能力
5.DefaultEventLoop
单线程任务执行器的默认实现，主要就是其实现的run方法
protected void run() {
//循环阻塞的获取任务，知道被通知关闭
for (;;) {
Runnable task = takeTask();
if (task != null) {
task.run();
updateLastExecutionTime();
}
if (confirmShutdown()) {
break;
}
}
}
6.总结
通过以上分析，不难看出Netty首先定义了自己的线程池（EventExectorGroup）和执行器（EventExector），然后通过继承的方式定义了线程池（EventLoopGroup）和执行器（EventLoop），从而添加了处理（注册）channel的能力。
You gotta grab what you can when you can.
机不可失，时不我待。
