接口定义
io.netty.channel.EventLoopGroup extends EventExecutorGroup
io.netty.channel.EventLoop extends OrderedEventExecutor, EventLoopGroup
EventLoopGroup定义的主要方法是register, 这个方法的语义是把channel和eventLoop绑定在一起。一个channel对应一个eventLoop, 一个eventLoop会持有多个channel。
I/O线程EventLoopGroup的抽象实现
io.netty.channel.MultithreadEventLoopGroup extends MultithreadEventExecutorGroup implements EventLoopGroup
io.netty.channel.SingleThreadEventLoop extends SingleThreadEventExecutor implements EventLoop
两个类主功能都是实现了EventLoopGroup定义的register方法
MultithreadEventLoopGroup
public ChannelFuture register(Channel channel) {
return next().register(channel);
}
public ChannelFuture register(Channel channel, ChannelPromise promise) {
return next().register(channel, promise);
}
SingleThreadEventLoop
public ChannelFuture register(Channel channel) {
return register(channel, new DefaultChannelPromise(channel, this));
}
public ChannelFuture register(final Channel channel, final ChannelPromise promise) {
channel.unsafe().register(this, promise);
return promise;
}
register的实现主要是为了调用Channel.Unsafe实例的register方法。
NIO实现
io.netty.channel.nio.NioEventLoopGroup extends MultithreadEventLoopGroup
io.netty.channel.nio.NioEventLoop extends SingleThreadEventLoop
NioEventLoopGroup是在MultithreadEventLoopGroup基础上实现了对JDK NIO Selector的封装, 它实现以下几个功能:
- 创建selector
- 在selector上注册channel感兴趣的NIO事件
- 实现EventExecutor的run方法，定义NIO事件和Executor任务的处理流程。
- 把NIO事件转换成对channel unsafe的调用或NioTask的调用
- 控制线程执行I/O操作和排队任务的用时比例
- 处理epoll selector cpu 100%的bug
下面来具体分析这几个功能的实现。
创建Selector
NioEventLoop#openSelector()实现了创建selector的功能，默认情况下，使用SelectorProvider#openSelector()方法创建一个新个selector:
final Selector unwrappedSelector = provider.openSelector();
如果设置环境变量io.netty.noKeySetOptimization=true, 会创建一个selectedKeySet = new SelectedSelectionKeySet(), 然后使用java的反射机制把selector的selectedKeys和publicSelectedKeys替换成selectedKeySet，具体步骤是:
1.得到selector的真正类型: sun.nio.ch.SelectorImpl
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;
2.替换selector是属性unwrappedSelector
Field selectedKeysField = selectorImplClass.getDeclaredField("selectedKeys");
Field publicSelectedKeysField = selectorImplClass.getDeclaredField("publicSelectedKeys");
selectedKeysField.set(unwrappedSelector, selectedKeySet);
publicSelectedKeysField.set(unwrappedSelector, selectedKeySet);
之所以会设计一个这样的优化选项，是因为一般情况下调用完selector的select或selectNow方法后需要调用Selector#selectedKeys()得到触发NIO事件的的SelectableChannel，这样优化之后，可以直接从selectedKeySet中得到已经触发了NIO事件的SelectableChannel。
在selector上注册channel感兴趣的NIO事件
NioEventLoop提供了unwrappedSelector方法，这个方法返回了它创建好的Selector实例。这样任何的外部类都可以把任意的SelectableChannel注册到这selector上。在AbstractNioChannel中， doRegister方法的实现就是使用了这个方法:
selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);
另外，它还提供了一个register方法:
public void register(final SelectableChannel ch, final int interestOps, final NioTask<?> task)
这个方法会把task当成SelectableChannel的附件注册到selector上:
ch.register(selector, interestOps, task);
实现EventExecutor的run方法，定义NIO事件和Executor任务的处理流程
在NioEventLoop的run方法中实现NIO事件和EventExecutor的任务处理逻辑，这个run方法在io.netty.util.concurrent.SingleThreadEventExecutor中定义。在上一章中，我们看到了DefaultEventExecutor中是如何实现这个run方法的，这里我们将要看到这run方法的另一个实现。和SingleThreadEventExecutor中的run方法相比，NioEventLoop的run方法不仅要及时地执行taskQueue中的任务，还要能及时地处理NIO事件，因此它会同时检查selector中的NIO事件和和taskQueue队列，任何一个中有事件需要处理或有任务需要执行，它不会阻塞线程。同时它也保证了在没有NIO事件和任务的情况下线程不会无谓的空转浪费CUP资源。
run主要实现如下，为了更清晰的说明它的主要功能，我对原来的代码进行了一些删减。
for(;;){
try{
//phase1: 同时检查NIO事件和任务
switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {
case SelectStrategy.CONTINUE:
continue;
case SelectStrategy.SELECT:
select(wakenUp.getAndSet(false)); //在taskQueue中没有任务的时候执行select
}
//phase2: 进入处理NIO事件，执行executor任务
try{
//处理NIO事件
processSelectedKeys();
}finally{
//处理taskQueu中的任务
runAllTasks();
}
}catch(Throwable t){
handleLoopException(t);
}
}
run方法有两个阶段构成：
phase1: 检查NIO事件或executor任务，如果有任何的NIO事件或executor任务进入phase2。
这样阶段的主要工作在selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())和select中完成。
selectStrategy.calculateStrategy实现
selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())
这行代码的含义是: 如果hasTasks() == true, 调用以下selector#selectNow, 然后进入phase2。 否则调用select。这里使用了strategy模式，默认的strategy实现是io.netty.channe.DefaultSelectStrategy implements SelectStrategy
@Override
public int calculateStrategy(IntSupplier selectSupplier, boolean hasTasks) throws Exception {
return hasTasks ? selectSupplier.get() : SelectStrategy.SELECT;
}
DefaultSelectStrategy实现了SelectStrategy接口，这接口定义了两个常量:
int SELECT = -1;
int CONTINUE = -2;
运行时selectSuppler参数传入的是selectNowSupplier, 它的实现如下：
private final IntSupplier selectNowSupplier = new IntSupplier() {
@Override
public int get() throws Exception {
return selectNow();
}
};
这里的get方法调用了selectNow, selectNow调用的是Selector#selectNew方法，这个方法的返回值是>=0。
hashTasks的传入的参数是hasTask()的返回值: return !taskQueue.isEmpty();
代码读到这里就会发现，使用默认的的SelectStrategy实现，calculateStrategy在hasTasks()==true时返回值>=0, hasTasks() == false时返回值是SelectStrategy.SELECT，不会返回SelectStrategy.CONTINUE。
select实现
select的执行逻辑是:
1. 计算超select方法的结束时间selectDeadLineNanos
long currentTimeNanos = System.nanoTime();
long selectDeadLineNanos = currentTimeNanos + delayNanos(currentTimeNanos);
2. 进入循环，检查超时--超时跳出循环。
long timeoutMillis = (selectDeadLineNanos - currentTimeNanos + 500000L) / 1000000L;
if (timeoutMillis <= 0) {
if (selectCnt == 0) {
selector.selectNow();
selectCnt = 1;
}
break;
}
3. 如果在select执行过程中有executor任务提交或可以当前的wakeUp由false变成true, 跳出循环
if (hasTasks() && wakenUp.compareAndSet(false, true)) {
selector.selectNow();
selectCnt = 1;
break;
}
4. 调用selector#select等待NIO事件。
int selectedKeys = selector.select(timeoutMillis);
selectCnt ++;
5. 如果满足这些条件的任何一个，跳出循环: 有NIO事件、wakeUp的新旧值都是true、taskQueue中有任务、有定时任务到期。
if (selectedKeys != 0 || oldWakenUp || wakenUp.get() || hasTasks() || hasScheduledTasks()) {
break;
}
6. 如果线程被中断，跳出循环。
if (Thread.interrupted()) {
break;
}
7. 如果selector.select超时，没有检查到任何NIO事件, 会在下次循环开始时跳出循环。 如果每次超时，跳到第2步继续下一次循环。
long time = System.nanoTime();
if (time - TimeUnit.MILLISECONDS.toNanos(timeoutMillis) >= currentTimeNanos) {
selectCnt = 1;
}
currentTimeNanos = time;
select 最迟会在当前时间>= selectDeadLineNanos时返回，这个时间是最近一个到期的定时任务执行的时间，换言之如果没有任何的NIO事件或executor任务，select会在定时任务到期时返回。如果没有定时任务，delayNanos(currentTimeNanos)返回的值是 TimeUnit.SECONDS.toNanos(1)，即1秒。 select会在检查到任何NIO事件或executor任务时返回，为了保证这点，在selector.select(timeoutMillis)前后都会调用hasTasks检查executor任务，为了能在调用executet提交任务时唤醒selector.select，NioEventLoop覆盖了SingleThreadEventExecutor的wake方法:
protected void wakeup(boolean inEventLoop) {
if (!inEventLoop && wakenUp.compareAndSet(false, true)) {
selector.wakeup();
}
}
这个方法会及时的唤醒selector.select, 保证新提交的任务可以得到及时的执行。
phase2: 进入处理NIO事件，执行executor任务
这个阶段是先调用processSelectedKeys()处理NIO事件，然后掉用 runAllTasks()处理所有已经到期的定时任务和已经在排队的任务。这个阶段还实现了NIO事件和executor任务的用时比例管理，这个特性稍后会详细分析。