Netty的异步任务处理与Socket事件处理
有道无术，术尚可求也！有术无道，止于术！
经过前面几章的学习，我们基本是明白了Netty通道的创建、注册、与绑定与JDK NIO的对应关系，如果我们使用的是JDK NIO的方式去开发一个Socket服务端的时候，此时还缺少了一个重要的环节，就是循环处理IO事件！
我们前面不只一次的见到Netty的异步事件，因为我们某些知识还没有学习到，所以我们都按照同步的方式去获取的，所以我们本章节将带你学习，Netty对于IO事件的处理与异步事件的处理！
我们以绑定为出发点，由点到面进行分析！
一、源码入口
我们直接进入到绑定的源码分析：
private static void doBind0(
final ChannelFuture regFuture, final Channel channel,
final SocketAddress localAddress, final ChannelPromise promise) {
// 在触发channelRegistered（）之前调用此方法。给用户处理程序一个设置的机会
// 其channelRegistered（）实现中的管道。
channel.eventLoop().execute(() -> {
if (regFuture.isSuccess()) {
channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
} else {
promise.setFailure(regFuture.cause());
}
});
}
我们上节课直接分析的channel.bind方法，而忽略上上面的异步方法，这里我们开始分析异步方法，我们进入到channel.eventLoop().execute()方法：
二、源码分析
我们前面分析过，每个Channel绑定一个NioEventLoop，而EventLoop又是SingleThreadEventExecutor的子类，所以我们进入到io.netty.util.concurrent.SingleThreadEventExecutor#execute(java.lang.Runnable)：
@Override
public void execute(Runnable task) {
ObjectUtil.checkNotNull(task, "task");
execute(task, !(task instanceof LazyRunnable) && wakesUpForTask(task));
}
---------------------------分界线------------------------------------
//继续往下追 execute
private void execute(Runnable task, boolean immediate) {
//判断当前执行的线程是不是 NIoEventLoopGroup的线程 这里是false
boolean inEventLoop = inEventLoop();
//将任务加入到队列
addTask(task);
//这里永远只能启动一次 一个eventLoop
if (!inEventLoop) {
//启动线程
startThread();
.....................................
}
//io.netty.channel.nio.NioEventLoop.selector
if (!addTaskWakesUp && immediate) {
wakeup(inEventLoop);
}
}
我们这里可以分为两部分：
1. 添加任务
addTask(task);
----------------------------------分界线---------------------------
protected void addTask(Runnable task) {
ObjectUtil.checkNotNull(task, "task");
if (!offerTask(task)) {
reject(task);
}
}
基础好一点的同学我估计已经有点猜到了，单看这个 offerTask有没有像和队列相关的操作，我们进入到offerTask方法：
final boolean offerTask(Runnable task) {
...............忽略.................
return taskQueue.offer(task);
}
果不其然，果然是入队操作，taskQueue是什么呢？
我们再初始化NioEventLoop的源码分析学习的时候，学习到，我们会创建两个MpscQ队列(多生产者，单消费者)，这个taskQueue就是当时我们创建的一个任务队列，这里面将我们提交的异步任务追加到队列里面！
返回异步任务是不是被追加到队列里面了，如果队列满了，或者其他原因追加失败的话，会返回false，就会执行reject方法：
protected final void reject(Runnable task) {
rejectedExecutionHandler.rejected(task, this);
}
这个拒绝策略同样是我们再创建NioEventLoop的时候创建保存的，给大家留一个作业，去追一下这个拒绝策略，判断一下当发生了添加异步任务失败之后，会发生什么呢？
2. 启动消费线程
startThread();
-----------------------------分割线-------------------------
/**
* 启动线程
*/
private void startThread() {
if (state == ST_NOT_STARTED) {
if (STATE_UPDATER.compareAndSet(this, ST_NOT_STARTED, ST_STARTED)) {
boolean success = false;
try {
//启动线程
doStartThread();
success = true;
} finally {
if (!success) {
STATE_UPDATER.compareAndSet(this, ST_STARTED, ST_NOT_STARTED);
}
}
}
}
}
注意，这里有个CAS操作 STATE_UPDATER.compareAndSet(this, ST_NOT_STARTED, ST_STARTED); 判断消费线程是不是已经启动，如果已经启动就不进入这个逻辑，如果没启动就进入这个逻辑！我们第一次调用，肯定没启动，进入这个逻辑：
doStartThread();
----------------------------分割线---------------------------
private void doStartThread() {
assert thread == null;
//创建一条线程并启动
//这个线程又EventLoop
executor.execute(new Runnable() {
@Override
public void run() {
//保存当前线程 给线程赋值的就是这里
thread = Thread.currentThread();
...........................忽略........................
try {
//进行实际的启动
//io.netty.channel.nio.NioEventLoop.run
SingleThreadEventExecutor.this.run();
success = true;
} catch (Throwable t) {
logger.warn("Unexpected exception from an event executor: ", t);
} finally {
...........................忽略........................
}
}
...........................忽略........................
}
...........................忽略........................
}
代码比较长，我们只分析主线逻辑：
thread = Thread.currentThread();
首先保存了一下当前线程到成员变量，这个分支不是很重要，后面有时间进行分析！
SingleThreadEventExecutor.this.run();
这个就是处理异步任务的代码，我们进入到run方法查看：
@Override
protected void run() {
int selectCnt = 0;
for (;;) {
try {
int strategy;
try {
//存在任务就返回IO时间的数量，不存在任务就返回select阻塞等待事件发生
strategy = selectStrategy.calculateStrategy(selectNowSupplier, hasTasks());
switch (strategy) {
case SelectStrategy.CONTINUE:
continue;
case SelectStrategy.BUSY_WAIT:
//如果不存在异步任务 就进行事件选择
case SelectStrategy.SELECT:
//下一个定时任务的截至时间 当不存在任务的时候就返回-1
long curDeadlineNanos = nextScheduledTaskDeadlineNanos();
if (curDeadlineNanos == -1L) {
curDeadlineNanos = NONE;
}
nextWakeupNanos.set(curDeadlineNanos);
try {
//不存在任务就去阻塞获取IO事件
if (!hasTasks()) {
strategy = select(curDeadlineNanos);
}
} finally {
nextWakeupNanos.lazySet(AWAKE);
}
default:
}
} catch (IOException e) {
//替换一个选择器
rebuildSelector0();
//选择次数重置为0
selectCnt = 0;
//处理循环异常 主要处理方式就是睡眠一会让程序主动释放CPU
handleLoopException(e);
continue;
}
//本次循环次数+1
selectCnt++;
cancelledKeys = 0;
needsToSelectAgain = false;
//这里是默认值 50
final int ioRatio = this.ioRatio;
boolean ranTasks;
//不会进这个分支
if (ioRatio == 100) {
try {
if (strategy > 0) {
processSelectedKeys();
}
} finally {
// Ensure we always run tasks.
ranTasks = runAllTasks();
}
//当存在I/O事件的时候
} else if (strategy > 0) {
//记录一下当前的时间
final long ioStartTime = System.nanoTime();
try {
//处理IO事件
processSelectedKeys();
} finally {
//计算处理IO事件耗费的事件
final long ioTime = System.nanoTime() - ioStartTime;
//里面的时间是计算处理异步任务的时间尽量保持为1:1
ranTasks = runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
}
} else {
//没有IO事件的话就处理异步任务
ranTasks = runAllTasks(0);
}
if (ranTasks || strategy > 0) {
if (selectCnt > MIN_PREMATURE_SELECTOR_RETURNS && logger.isDebugEnabled()) {
logger.debug("Selector.select() returned prematurely {} times in a row for Selector {}.",
selectCnt - 1, selector);
}
//没有空轮询的话三次一清空
selectCnt = 0;
//如果空轮询的次数超过默认的512次 就处理空轮询BUG的选择器
} else if (unexpectedSelectorWakeup(selectCnt)) {
//空轮询被处理后清空 轮询次数
selectCnt = 0;
}
} catch (CancelledKeyException e) {
...................忽略........................
} finally {
...................忽略........................
}
}
}
这主线逻辑分为三个：如何解决IO事件、如何处理异步任务、如何解决空轮询BUG！！分支代码关注一下注释，这里分析下主线代码：
I. I/O事件的处理
processSelectedKeys();
private void processSelectedKeys() {
if (selectedKeys != null) {
processSelectedKeysOptimized();
} else {
processSelectedKeysPlain(selector.selectedKeys());
}
}
selectedKeys是我们在创建NIOEventLoop的时候，会创建一个优化后的的SelectorKeySet集合，使用数组来实现的，大家忘记的话，可以会看一下NioEventLoop的初始化源码篇！
当你没有禁用优化的时候，就会进入到if分支，我们查看if内部代码的源码：
private void processSelectedKeysOptimized() {
//开始遍历所有的主键
for (int i = 0; i < selectedKeys.size; ++i) {
//获取事件
final SelectionKey k = selectedKeys.keys[i];
//将该位置的数据制空
selectedKeys.keys[i] = null;
//获取之间注册NioServerSocketChannel的时候，绑定的Channel对象
final Object a = k.attachment();
if (a instanceof AbstractNioChannel) {
//开始进行IO事件处理
processSelectedKey(k, (AbstractNioChannel) a);
} else {
.........................忽略............................
}
.........................忽略............................
}
}
获取事件集合中的每一个key，同时获取之前绑定的NioServerSocketChannel，然后调用processSelectedKey处理这个事件：
private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();
if (!k.isValid()) {
//当key失效之后，就关闭通道
....................忽略....................
}
try {
//获取当前事件的key 掩码
int readyOps = k.readyOps();
//是否包含连接事件
if ((readyOps & SelectionKey.OP_CONNECT) != 0) {
//获取包含的事件
int ops = k.interestOps();
//剔除OP_CONNECT事件
ops &= ~SelectionKey.OP_CONNECT;
//重新更新关注的事件
k.interestOps(ops);
//传播 connect事件
unsafe.finishConnect();
}
//如果当前返回的关注事件的掩码包含 OP_WRITE的话
if ((readyOps & SelectionKey.OP_WRITE) != 0) {
//开始向通道内刷新数据
ch.unsafe().forceFlush();
}
//如果当前的事件掩码包含读、新连接接入事件 或者 不关注任何事件的时候 传播read事件
if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) { //传播read事件 可能是新连接接入也可能有数据可读
unsafe.read();
}
} catch (CancelledKeyException ignored) {
//发生异常关闭通道
unsafe.close(unsafe.voidPromise());
}
}
大家可以看到，里面的处理基本和我们对于JDK NIO的处理一致，就是判断各种事件然后进行对应的处理！
II、异步任务的处理
runAllTasks();
protected boolean runAllTasks() {
assert inEventLoop();
boolean fetchedAll;
boolean ranAtLeastOne = false;
do {
//合并任务 将定时任务的队列里面的任务拉去出来，和异步任务的队列进行合并
fetchedAll = fetchFromScheduledTaskQueue();
//开始执行全部的任务
if (runAllTasksFrom(taskQueue)) {
ranAtLeastOne = true;
}
} while (!fetchedAll);
if (ranAtLeastOne) {
lastExecutionTime = ScheduledFutureTask.nanoTime();
}
afterRunningAllTasks();
return ranAtLeastOne;
}
这里就是异步任务的被执行的地方，这里分为两个步骤：1. 合并任务 2.执行taskQueue异步任务 3.执行tailQueue异步任务！
合并任务
fetchedAll = fetchFromScheduledTaskQueue();Netty在我们学习中已经知道了两种队列，一种是taskQueue队列，一种是tailQueue队列，现在又出现了第三种队列：
scheduledTaskQueue，他是一个专门存放定时任务的对队列，这里的合并任务就是将即将要执行的任务合并到taskQueue中等待执行！这行代码执行完毕后，所有即将要执行的任务都被添加在了taskQueue队列中，等待后续的执行！
执行taskQueue异步任务
//注意这里传入的是合并完成后额taskQueue
runAllTasksFrom(taskQueue)上述代码将对应的任务全部集中到了taskQueue队列中后们这里开始消费taskQueue队列进行执行！我们可以适当的看一下源码：
protected final boolean runAllTasksFrom(Queue<Runnable> taskQueue) {
//从taskQueue队列中弹出一个任务
Runnable task = pollTaskFrom(taskQueue);
if (task == null) {
return false;
}
for (;;) {
//执行任务 调用run方法
safeExecute(task);
//继续弹出任务
task = pollTaskFrom(taskQueue);
//如果弹出的任务为空
if (task == null) {
//直接返回
return true;
}
}
}执行tailQueue异步任务
afterRunningAllTasks();这里开始执行tailQueue节点的任务，可以看到，tailQueue节点的任务执行优先级低于上述两种队列！
image-20210503101059511 @Override
protected void afterRunningAllTasks() {
//注意这里传入的是 tailQueue
runAllTasksFrom(tailTasks);
}
//继续往下看源码
protected final boolean runAllTasksFrom(Queue<Runnable> taskQueue) {
//弹出任务
Runnable task = pollTaskFrom(taskQueue);
if (task == null) {
return false;
}
for (;;) {
//执行任务
safeExecute(task);
//再次弹出任务
task = pollTaskFrom(taskQueue);
if (task == null) {
//任务执行完毕 返回true
return true;
}
}
}这里就不作过多讲解了，这里和上面的逻辑基本一致，只是执行的qeueb不是一个！
III、解决臭名昭著的JDK空轮询BUG
可能大家大家都知道，JDK NIO在事件循环判断的时候可能会出现空轮询的BUG，导致CPU100%，虽然Oracle官方宣称空轮询的BUG已经解决了，但是后续经过一些公司实际的业务上证明并没有解决，只是出现几率小了点，Netty事实上并没有解决这个空轮询BUG只是用另外一种比较巧妙的方法规避开了，我们一起学习下：
首先，我们先想一下，我们如何断定我们的程序可能发生了空轮询的BUG，学习过NIO的都知道，我们会调用一个selector.select()进行阻塞等待有完成的事件发生，当selet方法阻塞解除的时候，就证明一定有我么感兴趣的事件发生，但是当我们发现select方法解除了阻塞，但是事件数量却为0的时候，我们就认为可能出现了空轮询的BUG！
但是IO数量为0并不是一定出现了空轮询的BUG，也可能外部调用了markUp方法，所以我们不能每一次出现事件数量为0的时候都认为程序出现了空轮询BUG，所以我们就需要有一个记录它出现该类异常情况发生的次数，当发生的次数达到了我们设置的阈值，就证明它可能发生了空轮询的BUG，这个时候需要处理这个空轮询的BUG！
那么如何处理呢？ 我们任务发生空轮询问题是因为（JDK官方认为，这个Linux Epoll告诉JDK有事件了，但是JDK获取事件的时候获取了一个空，所以JDK只能返回一个0）所以就发生了空轮询：
JDK官方给出的解决方案
Netty是使用的第三种，抛弃旧的选择器，重建一个新的选择器，然后替换旧的选择器，我们一起看下源码！
我们看看Netty是如何做的，我们回到io.netty.channel.nio.NioEventLoop#run源码：
我还是，为了方便讲解，把这段代码贴出来省略和空轮询无关的代码（完整代码见上）：
@Override
protected void run() {
int selectCnt = 0;
for (;;) {
........................忽略进行事件选择的代码...................
//本次循环次数+1
selectCnt++;
....................忽略事件处理和异步任务执行的代码................
//当处理的异步任务或者IO事件的数量大于0,证明没有发生空轮询
if (ranTasks || strategy > 0) {
//每隔三次打印一次日志
if (selectCnt > MIN_PREMATURE_SELECTOR_RETURNS && logger.isDebugEnabled()) {
logger.debug("Selector.select() returned prematurely {} times in a row for Selector {}.",
selectCnt - 1, selector);
}
//没有空轮询的话清空
selectCnt = 0;
//如果出现异步任务为空 IO事件为空的话就会进入到这个逻辑
} else if (unexpectedSelectorWakeup(selectCnt)) {
//空轮询被处理后清空 轮询次数
selectCnt = 0;
}
} catch (CancelledKeyException e) {
...................忽略........................
} finally {
...................忽略........................
}
}
可以仔细的看一下 上述代码的注释，我们进入到 unexpectedSelectorWakeup(selectCnt) 方法：
private boolean unexpectedSelectorWakeup(int selectCnt) {
..............忽略日志打印................
if (SELECTOR_AUTO_REBUILD_THRESHOLD > 0 &&
//判断异常情况的次数是不是超过了预设的512次
selectCnt >= SELECTOR_AUTO_REBUILD_THRESHOLD) {
//开始重新构建一个selector
rebuildSelector();
return true;
}
return false;
}
我们读源码到这里，可以知道，当异常执行的次数超过了阈值 512次，就会调用一个 rebuildSelector方法，我们点进去看一下：
public void rebuildSelector() {
if (!inEventLoop()) {
execute(new Runnable() {
@Override
public void run() {
rebuildSelector0();
}
});
return;
}
rebuildSelector0();
}
我们按照惯例，按照同步方法调用 rebuildSelector0();
private void rebuildSelector0() {
//获取原始的选择器
final Selector oldSelector = selector;
//声明一个新的选择器
final SelectorTuple newSelectorTuple;
if (oldSelector == null) {
return;
}
try {
//创建一个新的选择器，赋值给新的选择器变量
newSelectorTuple = openSelector();
} catch (Exception e) {
logger.warn("Failed to create a new Selector.", e);
return;
}
int nChannels = 0;
//开始遍历旧的选择器，将旧选择器的IO事件的key，绑定到新创建的选择器上
for (SelectionKey key: oldSelector.keys()) {
//获取旧选择器的管道
Object a = key.attachment();
try {
//如果key失效了，就跳过！
if (!key.isValid() || key.channel().keyFor(newSelectorTuple.unwrappedSelector) != null) {
continue;
}
//获取对应关注的事件掩码
int interestOps = key.interestOps();
//将旧key置为失效
key.cancel();
//重新将管道绑定到新的选择器上
SelectionKey newKey = key.channel().register(newSelectorTuple.unwrappedSelector, interestOps, a);
//替换管道里面保存的选择器事件主键
if (a instanceof AbstractNioChannel) {
// Update SelectionKey
((AbstractNioChannel) a).selectionKey = newKey;
}
nChannels ++;
} catch (Exception e) {
...............省略...............
}
}
//重新保存新的优化后的选择器和原始选择器
selector = newSelectorTuple.selector;
unwrappedSelector = newSelectorTuple.unwrappedSelector;
try {
//关闭旧的选择器
oldSelector.close();
} catch (Throwable t) {
if (logger.isWarnEnabled()) {
...............省略..................
}
}
...............省略..................
}
我们从上述代码可以看到，Netty处理空轮询的问题的策略是，当发现你可能发生空轮询的次数超过了512次的时候，就直接重新获取一个新的选择器，然后将旧的选择器直接替换掉，这样空轮询的BUG也就很轻易的解决了！
三、总结
每一个EventLoop都会启动一条永久运行的线程，用于处理异步任务和IO事件，我们称之为Reactor线程。 如果存在IO事件的话，会先处理IO事件！ Reactor线程会先将定时任务里面的任务合并到taskqueue里面，然后执行！taskQueue执行完毕后执行tailQueue队列的任务！ 如果空轮询的次数发生了512次，就认为发生了空轮询的BUG，就会抛弃原来的选择器，重建一个新的选择器，将旧选择器上的事件全部绑定到新的选择器上，然后将旧选择器删除！
才疏学浅，如果文章中理解有误，欢迎大佬们私聊指正！欢迎关注作者的公众号，一起进步，一起学习！
❤️「转发」和「在看」，是对我最大的支持❤️