Netty NioEventLoop启动过程是怎样的

本篇内容介绍了“Netty NioEventLoop启动过程是怎样的”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

启动

分析NioEventLoop的execute()接口，主要逻辑如下：

• 添加任务队列

• 绑定当前线程到EventLoop上

• 调用EventLoop的run()方法

private static void doBind0(        final ChannelFuture regFuture, final Channel channel,        final SocketAddress localAddress, final ChannelPromise promise) {    // 通过eventLoop来执行channel绑定的Task
    channel.eventLoop().execute(new Runnable() {        @Override
        public void run() {            if (regFuture.isSuccess()) {                // channel绑定
                channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
            } else {
                promise.setFailure(regFuture.cause());
            }
        }
    });
}

往下追踪到 SingleThreadEventExecutor 中 execute 接口，如下：

@Overridepublic void execute(Runnable task) {    if (task == null) {        throw new NullPointerException("task");
    }    // 判断当前运行时线程是否与EventLoop中绑定的线程一致
    // 这里还未绑定Thread，所以先返回false
    boolean inEventLoop = inEventLoop();    // 将任务添加任务队列，也就是我们前面讲EventLoop创建时候提到的 MpscQueue.
    addTask(task);    if (!inEventLoop) {        // 启动线程
        startThread();        if (isShutdown() && removeTask(task)) {
            reject();
        }
    }    if (!addTaskWakesUp && wakesUpForTask(task)) {
        wakeup(inEventLoop);
    }
}

启动线程接口：

private void startThread() {    // 状态比较，最开始时state = 1 ，为true
    if (state == ST_NOT_STARTED) {        // cs操作后，state状态设置为 2
        if (STATE_UPDATER.compareAndSet(this, ST_NOT_STARTED, ST_STARTED)) {            try {                // 启动接口
                doStartThread();
            } catch (Throwable cause) {
                STATE_UPDATER.set(this, ST_NOT_STARTED);
                PlatformDependent.throwException(cause);
            }
        }
    }
}// 执行线程启动方法private void doStartThread() {    // 断言判断 SingleThreadEventExecutor 还未绑定 Thread
    assert thread == null;    // executor 执行任务
    executor.execute(new Runnable() {        @Override
        public void run() {            // 将 SingleThreadEventExecutor(在我们的案例中就是NioEventLoop) 与 当前线程进行绑定
            thread = Thread.currentThread();            if (interrupted) {
                thread.interrupt();
            }            // 设置状态为 false
            boolean success = false;            // 更新最近一次任务的执行时间
            updateLastExecutionTime();            try {                // 往下调用 NioEventLoop 的 run 方法，执行
                SingleThreadEventExecutor.this.run();
                success = true;
            } catch (Throwable t) {
                logger.warn("Unexpected exception from an event executor: ", t);
            } finally {
               
               ...
               
            }
        }
    });
}

执行

往下调用到 NioEventLoop 中的 run 方法，通过无限for循环，主要做以下三件事情：

• 轮循I/O事件：select(wakenUp.getAndSet(false))

• 处理I/O事件：processSelectedKeys

• 运行Task任务：runAllTasks

@Overrideprotected void run() {    for (;;) {        try {            switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {                case SelectStrategy.CONTINUE:                    continue;                case SelectStrategy.SELECT:                    // 轮训检测I/O事件
                    // wakenUp为了标记selector是否是唤醒状态，每次select操作，都设置为false，也就是未唤醒状态。
                    select(wakenUp.getAndSet(false));                    // 'wakenUp.compareAndSet(false, true)' 总是在调用 'selector.wakeup()' 之前进行评估，以减少唤醒的开销
                    // (Selector.wakeup() 是非常耗性能的操作.)
                    
                    // 但是，这种方法存在竞争条件。当「wakeup」太早设置为true时触发竞争条件
                    
                    // 在下面两种情况下，「wakenUp」会过早设置为true：
                    // 1）Selector 在 'wakenUp.set(false)' 与 'selector.select(...)' 之间被唤醒。(BAD)
                    // 2）Selector 在 'selector.select(...)' 与 'if (wakenUp.get()) { ... }' 之间被唤醒。(OK)
                    
                    // 在第一种情况下，'wakenUp'设置为true，后面的'selector.select（...）'将立即唤醒。 直到'wakenUp'在下一轮中再次设置为false，'wakenUp.compareAndSet（false，true）'将失败，因此任何唤醒选择器的尝试也将失败，从而导致以下'selector.select（。 ..）'呼吁阻止不必要的。
                    
                    // 要解决这个问题，如果在selector.select（...）操作之后wakenUp立即为true，我们会再次唤醒selector。 它是低效率的，因为它唤醒了第一种情况（BAD - 需要唤醒）和第二种情况（OK - 不需要唤醒）的选择器。
                    if (wakenUp.get()) {
                        selector.wakeup();
                    }                    // fall through
                default:
            }
            cancelledKeys = 0;
            needsToSelectAgain = false;            // ioRatio 表示处理I/O事件与执行具体任务事件之间所耗时间的比值。
            // ioRatio 默认为50
            final int ioRatio = this.ioRatio;            if (ioRatio == 100) {                try {                    // 处理I/O事件
                    processSelectedKeys();
                } finally {                    // 处理任务队列
                    runAllTasks();
                }
            } else {                // 处理IO事件的开始时间
                final long ioStartTime = System.nanoTime();                try {                    // 处理I/O事件
                    processSelectedKeys();
                } finally {                    // 记录io所耗时间
                    final long ioTime = System.nanoTime() - ioStartTime;                    // 处理任务队列，设置最大的超时时间
                    runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
                }
            }
        } catch (Throwable t) {
            handleLoopException(t);
        }        
        // Always handle shutdown even if the loop processing threw an exception.
        try {            if (isShuttingDown()) {
                closeAll();                if (confirmShutdown()) {                    return;
                }
            }
        } catch (Throwable t) {
            handleLoopException(t);
        }
    }
}

轮循检测I/O事件

private void select(boolean oldWakenUp) throws IOException {
    Selector selector = this.selector;    try {        // select操作计数
        int selectCnt = 0;        // 记录当前系统时间
        long currentTimeNanos = System.nanoTime();        // delayNanos方法用于计算定时任务队列，最近一个任务的截止时间
        // selectDeadLineNanos 表示当前select操作所不能超过的最大截止时间
        long selectDeadLineNanos = currentTimeNanos + delayNanos(currentTimeNanos);        for (;;) {            // 计算超时时间，判断是否超时
            long timeoutMillis = (selectDeadLineNanos - currentTimeNanos + 500000L) / 1000000L;            // 如果 timeoutMillis <= 0， 表示超时，进行一个非阻塞的 select 操作。设置 selectCnt 为 1. 并终止本次循环。
            if (timeoutMillis <= 0) {                if (selectCnt == 0) {
                    selector.selectNow();
                    selectCnt = 1;
                }                break;
            }            // 当wakenUp为ture时，恰好有task被提交，这个task将无法获得调用的机会
            // Selector#wakeup. 因此，在执行select操作之前，需要再次检查任务队列
            // 如果不这么做，这个Task将一直挂起，直到select操作超时
            // 如果 pipeline 中存在 IdleStateHandler ，那么Task将一直挂起直到 空闲超时。
            
            if (hasTasks() && wakenUp.compareAndSet(false, true)) {                // 调用非阻塞方法
                selector.selectNow();
                selectCnt = 1;                break;
            }            // 如果当前任务队列为空，并且超时时间未到，则进行一个阻塞式的selector操作。timeoutMillis 为最大的select时间
            int selectedKeys = selector.select(timeoutMillis);            // 操作计数 +1
            selectCnt ++;			
            // 存在以下情况，本次selector则终止
            if (selectedKeys != 0 || oldWakenUp || wakenUp.get() || hasTasks() || hasScheduledTasks()) {                // - 轮训到了事件（Selected something,）
                // - 被用户唤醒（waken up by user,）
                // - 已有任务队列（the task queue has a pending task.）
                // - 已有定时任务（a scheduled task is ready for processing）
                break;
            }            if (Thread.interrupted()) {                // Thread was interrupted so reset selected keys and break so we not run into a busy loop.
                // As this is most likely a bug in the handler of the user or it's client library we will
                // also log it.
                //
                // See https://github.com/netty/netty/issues/2426
                if (logger.isDebugEnabled()) {
                    logger.debug("Selector.select() returned prematurely because " +                            "Thread.currentThread().interrupt() was called. Use " +                            "NioEventLoop.shutdownGracefully() to shutdown the NioEventLoop.");
                }
                selectCnt = 1;                break;
            }            // 记录当前时间
            long time = System.nanoTime();            // 如果time > currentTimeNanos + timeoutMillis(超时时间)，则表明已经执行过一次select操作
            if (time - TimeUnit.MILLISECONDS.toNanos(timeoutMillis) >= currentTimeNanos) {                // timeoutMillis elapsed without anything selected.
                selectCnt = 1;
            } 
            // 如果 time <= currentTimeNanos + timeoutMillis，表示触发了空轮训
            // 如果空轮训的次数超过 SELECTOR_AUTO_REBUILD_THRESHOLD (512)，则重建一个新的selctor，避免空轮训
            else if (SELECTOR_AUTO_REBUILD_THRESHOLD > 0 &&
                    selectCnt >= SELECTOR_AUTO_REBUILD_THRESHOLD) {                // The selector returned prematurely many times in a row.
                // Rebuild the selector to work around the problem.
                logger.warn(                        "Selector.select() returned prematurely {} times in a row; rebuilding Selector {}.",
                        selectCnt, selector);                // 重建创建一个新的selector
                rebuildSelector();
                selector = this.selector;                // Select again to populate selectedKeys.
                // 对重建后的selector进行一次非阻塞调用，用于获取最新的selectedKeys
                selector.selectNow();                // 设置select计数
                selectCnt = 1;                break;
            }
            currentTimeNanos = time;
        }        if (selectCnt > MIN_PREMATURE_SELECTOR_RETURNS) {            if (logger.isDebugEnabled()) {
                logger.debug("Selector.select() returned prematurely {} times in a row for Selector {}.",
                        selectCnt - 1, selector);
            }
        }
    } catch (CancelledKeyException e) {        if (logger.isDebugEnabled()) {
            logger.debug(CancelledKeyException.class.getSimpleName() + " raised by a Selector {} - JDK bug?",
                    selector, e);
        }        // Harmless exception - log anyway
    }
}

重新创建一个新的Selector

该方法的主要逻辑就是：

• 创建一个新的selector

• 将老的selector上的 selectKey注册到新的 selector 上

public void rebuildSelector() {    if (!inEventLoop()) {
        execute(new Runnable() {            @Override
            public void run() {
                rebuildSelector0();
            }
        });        return;
    }
    rebuildSelector0();
}// 重新创建selectorprivate void rebuildSelector0() {    // 暂存老的selector
    final Selector oldSelector = selector;    final SelectorTuple newSelectorTuple;    if (oldSelector == null) {        return;
    }    try {        // 创建一个新的 SelectorTuple
        // openSelector()在之前分析过了
        newSelectorTuple = openSelector();
    } catch (Exception e) {
        logger.warn("Failed to create a new Selector.", e);        return;
    }    // Register all channels to the new Selector.
    // 记录select上注册的channel数量
    int nChannels = 0;    // 遍历老的 selector 上的 SelectionKey 
    for (SelectionKey key: oldSelector.keys()) {        // 获取 attachment，这里的attachment就是我们前面在讲 Netty Channel注册时，select会将channel赋值到 attachment 变量上。
        // 获取老的selector上注册的channel 
        Object a = key.attachment();        try {            if (!key.isValid() || key.channel().keyFor(newSelectorTuple.unwrappedSelector) != null) {                continue;
            }			// 获取兴趣集
            int interestOps = key.interestOps();            // 取消 SelectionKey
            key.cancel();            // 将老的兴趣集重新注册到前面新创建的selector上
            SelectionKey newKey = key.channel().register(newSelectorTuple.unwrappedSelector, interestOps, a);            
            if (a instanceof AbstractNioChannel) {                // Update SelectionKey
                ((AbstractNioChannel) a).selectionKey = newKey;
            }            // nChannels计数 + 1
            nChannels ++;
        } catch (Exception e) {
            logger.warn("Failed to re-register a Channel to the new Selector.", e);            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
    selector = newSelectorTuple.selector;    // 设置新的 unwrappedSelector
    unwrappedSelector = newSelectorTuple.unwrappedSelector;    try {        // time to close the old selector as everything else is registered to the new one
        // 关闭老的seleclor
        oldSelector.close();
    } catch (Throwable t) {        if (logger.isWarnEnabled()) {
            logger.warn("Failed to close the old Selector.", t);
        }
    }    if (logger.isInfoEnabled()) {
        logger.info("Migrated " + nChannels + " channel(s) to the new Selector.");
    }
}

处理I/O事件

private void processSelectedKeysOptimized() {    for (int i = 0; i < selectedKeys.size; ++i) {        final SelectionKey k = selectedKeys.keys[i];        // null out entry in the array to allow to have it GC'ed once the Channel close
        // See https://github.com/netty/netty/issues/2363
        // 设置为null，有利于GC回收
        selectedKeys.keys[i] = null;		// 获取 SelectionKey 中的 attachment, 我们这里就是 NioChannel
        final Object a = k.attachment();        if (a instanceof AbstractNioChannel) {            // 处理 SelectedKey
            processSelectedKey(k, (AbstractNioChannel) a);
        } else {            @SuppressWarnings("unchecked")
            NioTask<SelectableChannel> task = (NioTask<SelectableChannel>) a;
            processSelectedKey(k, task);
        }        if (needsToSelectAgain) {            // 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
            selectedKeys.reset(i + 1);
            selectAgain();
            i = -1;
        }
    }
}// 处理 SelectedKeyprivate void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {    // 获取Netty Channel中的 NioUnsafe 对象，用于后面的IO操作
    final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();    // 判断 SelectedKey 的有效性，如果无效，则直接返回并关闭channel
    if (!k.isValid()) {        final EventLoop eventLoop;        try {
            eventLoop = ch.eventLoop();
        } catch (Throwable ignored) {            // If the channel implementation throws an exception because there is no event loop, we ignore this
            // because we are only trying to determine if ch is registered to this event loop and thus has authority
            // to close ch.
            return;
        }        // Only close ch if ch is still registered 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;
        }        // close the channel if the key is not valid anymore
        // 关闭channel
        unsafe.close(unsafe.voidPromise());        return;
    }    try {        // 获取 SelectionKey 中所有准备就绪的操作集
        int readyOps = k.readyOps();        // We first need to call finishConnect() before try to trigger a read(...) or write(...) as otherwise
        // the NIO JDK channel implementation may throw a NotYetConnectedException.
        // 在调用处理READ与WRITE事件之间，先调用finishConnect()接口，避免异常 NotYetConnectedException 发生。
        if ((readyOps & SelectionKey.OP_CONNECT) != 0) {            // remove OP_CONNECT as otherwise Selector.select(..) will always return without blocking
            // See https://github.com/netty/netty/issues/924
            int ops = k.interestOps();
            ops &= ~SelectionKey.OP_CONNECT;
            k.interestOps(ops);
            unsafe.finishConnect();
        }        // Process OP_WRITE first as we may be able to write some queued buffers and so free memory.
        // 处理 WRITE 事件
        if ((readyOps & SelectionKey.OP_WRITE) != 0) {            // Call forceFlush which will also take care of clear the OP_WRITE once there is nothing left to write
            ch.unsafe().forceFlush();
        }        // Also check for readOps of 0 to workaround possible JDK bug which may otherwise lead
        // to a spin loop
        // 处理 ACCEPT 与 READ 事件
        // 如果当前的EventLoop是WorkGroup，则表示有 READ 事件
        // 如果当前的EventLoop是BossGroup，则表示有 ACCEPT 事件，有新连接进来了
        if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {            // 读取数据
            unsafe.read();
        }
    } catch (CancelledKeyException ignored) {
        unsafe.close(unsafe.voidPromise());
    }
}

关于 unsafe.read() 的分析，请看  后文

执行所有任务

接下来，我们了解一下执行具体Task任务的接口：runAllTasks。在EventLoop中，待执行的任务队列分为两种：一种是普通任务队列，一种是定时任务队列。

前面  我们讲 EventLoop 创建时提到过NioEventLoop中 taskQueue 的创建，是一个MpscQueue，关于高效率的MpscQueue 后面单独写文章进行介绍：

public abstract class SingleThreadEventExecutor extends AbstractScheduledEventExecutor implements OrderedEventExecutor {
    
    ...	
    // 存放普通任务的队列
    private final Queue<Runnable> taskQueue;
    ...    
    protected SingleThreadEventExecutor(EventExecutorGroup parent, Executor executor,                                        boolean addTaskWakesUp, int maxPendingTasks,
                                        RejectedExecutionHandler rejectedHandler) {        super(parent);        this.addTaskWakesUp = addTaskWakesUp;        this.maxPendingTasks = Math.max(16, maxPendingTasks);        this.executor = ObjectUtil.checkNotNull(executor, "executor");        // 创建TaskQueue
        taskQueue = newTaskQueue(this.maxPendingTasks);
        rejectedExecutionHandler = ObjectUtil.checkNotNull(rejectedHandler, "rejectedHandler");
    }  
    
    ...
    
}public final class NioEventLoop extends SingleThreadEventLoop {
	... 
    // NioEventLoop 创建TaskQueue队列
	@Override
    protected Queue<Runnable> newTaskQueue(int maxPendingTasks) {        // This event loop never calls takeTask()
        return maxPendingTasks == Integer.MAX_VALUE ? PlatformDependent.<Runnable>newMpscQueue()
                                                    : PlatformDependent.<Runnable>newMpscQueue(maxPendingTasks);
    }
    
    
    ...
        
}

存放定时任务的队列在 AbstractScheduledEventExecutor 中，成员变量为 scheduledTaskQueue，代码如下：

public abstract class AbstractScheduledEventExecutor extends AbstractEventExecutor {	
    // 优先级队列的比较器
    private static final Comparator<ScheduledFutureTask<?>> SCHEDULED_FUTURE_TASK_COMPARATOR =            new Comparator<ScheduledFutureTask<?>>() {                @Override
                public int compare(ScheduledFutureTask<?> o1, ScheduledFutureTask<?> o2) {                    return o1.compareTo(o2);
                }
            };	
    // 存放定时任务的优先级队列
    PriorityQueue<ScheduledFutureTask<?>> scheduledTaskQueue;	// 创建定时任务队列    
    PriorityQueue<ScheduledFutureTask<?>> scheduledTaskQueue() {        if (scheduledTaskQueue == null) {
            scheduledTaskQueue = new DefaultPriorityQueue<ScheduledFutureTask<?>>(
                    SCHEDULED_FUTURE_TASK_COMPARATOR,                    // Use same initial capacity as java.util.PriorityQueue
                    11);
        }        return scheduledTaskQueue;
    }    
    // 保存定时任务
    @Override
    public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
        ObjectUtil.checkNotNull(command, "command");
        ObjectUtil.checkNotNull(unit, "unit");        if (delay < 0) {
            delay = 0;
        }
        validateScheduled0(delay, unit);        return schedule(new ScheduledFutureTask<Void>(                this, command, null, ScheduledFutureTask.deadlineNanos(unit.toNanos(delay))));
    }    // 保存定时任务
    @Override
    public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
        ObjectUtil.checkNotNull(callable, "callable");
        ObjectUtil.checkNotNull(unit, "unit");        if (delay < 0) {
            delay = 0;
        }
        validateScheduled0(delay, unit);        return schedule(new ScheduledFutureTask<V>(                this, callable, ScheduledFutureTask.deadlineNanos(unit.toNanos(delay))));
    }	// 保存定时任务
 	<V> ScheduledFuture<V> schedule(final ScheduledFutureTask<V> task) {        // 判断是否为当前线程
        if (inEventLoop()) {            // 添加定时任务队列
            scheduledTaskQueue().add(task);
        } else {
            execute(new Runnable() {                @Override
                public void run() {                    // 添加定时任务队列
                    scheduledTaskQueue().add(task);
                }
            });
        }        return task;
  	}
}

Netty存放定时任务队列为  DefaultPriorityQueue  ，定时任务的封装对象为 ScheduledFutureTask ，在队列中的优先按照它们的截止时间进行排序，其次在按照id进行排序。

final class ScheduledFutureTask<V> extends PromiseTask<V> implements ScheduledFuture<V>, PriorityQueueNode {
    ...	
    // 比较 ScheduledFutureTask 之间的排序
    @Override
    public int compareTo(Delayed o) {        if (this == o) {            return 0;
        }
		
        ScheduledFutureTask<?> that = (ScheduledFutureTask<?>) o;        long d = deadlineNanos() - that.deadlineNanos();        if (d < 0) {            return -1;
        } else if (d > 0) {            return 1;
        } else if (id < that.id) {            return -1;
        } else if (id == that.id) {            throw new Error();
        } else {            return 1;
        }
    }    
    
    ...
    
}

再来看看任务的执行逻辑，首先将定时任务取出，聚合到普通任务队列中，再去for循环运行每个Task。

protected boolean runAllTasks(long timeoutNanos) {    // 将定时任务从定时队列中取出，放入普通队列中
    fetchFromScheduledTaskQueue();    // 从队列中取出任务
    Runnable task = pollTask();    if (task == null) {
        afterRunningAllTasks();        return false;
    }	// 计算任务执行的最大超时时间
    final long deadline = ScheduledFutureTask.nanoTime() + timeoutNanos;    // 任务计数
    long runTasks = 0;    // 最近一次任务执行的时间
    long lastExecutionTime;    for (;;) {        // 执行任务
        safeExecute(task);		// 任务计数 +1
        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.
        // 由于nanoTime() 是非常好性能的操作，因此每64次就对比一下 定时任务的执行时间与 deadline，
        // 如果 lastExecutionTime >= deadline，则表示任务超时了，需要中断退出
        if ((runTasks & 0x3F) == 0) {
            lastExecutionTime = ScheduledFutureTask.nanoTime();            if (lastExecutionTime >= deadline) {                break;
            }
        }		
        // 获取任务
        task = pollTask();        if (task == null) {
            lastExecutionTime = ScheduledFutureTask.nanoTime();            break;
        }
    }
	
    afterRunningAllTasks();    // 记录最后一次的执行时间
    this.lastExecutionTime = lastExecutionTime;    return true;
}// 取出任务protected Runnable pollTask() {    assert inEventLoop();    return pollTaskFrom(taskQueue);
}// 从队列中取出任务protected static Runnable pollTaskFrom(Queue<Runnable> taskQueue) {    for (;;) {
        Runnable task = taskQueue.poll();        if (task == WAKEUP_TASK) {            continue;
        }        return task;
    }
}// 将定时任务从定时队列中取出，聚合到普通队列中：private boolean fetchFromScheduledTaskQueue() {    // 得到nanoTime = 当前时间 - ScheduledFutureTask的START_TIME(开始时间)
    long nanoTime = AbstractScheduledEventExecutor.nanoTime();    // 获得截止时间小于nanoTime的定时任务
    Runnable scheduledTask  = pollScheduledTask(nanoTime);    while (scheduledTask != null) {        // 将定时任务放入普通队列中，以备运行
        if (!taskQueue.offer(scheduledTask)) {            // No space left in the task queue add it back to the scheduledTaskQueue so we pick it up again.
            // 如果 taskQueue 没有足够的空间，导致添加失败，则将其返回定时任务队列中
            scheduledTaskQueue().add((ScheduledFutureTask<?>) scheduledTask);            return false;
        }
        scheduledTask  = pollScheduledTask(nanoTime);
    }    return true;
}// 获得截止时间小于nanoTime的定时任务protected final Runnable pollScheduledTask(long nanoTime) {    assert inEventLoop();	// 获取定时任务队列
    Queue<ScheduledFutureTask<?>> scheduledTaskQueue = this.scheduledTaskQueue;    // 获取第一个定时任务
    ScheduledFutureTask<?> scheduledTask = scheduledTaskQueue == null ? null : scheduledTaskQueue.peek();    if (scheduledTask == null) {        return null;
    }	// 如果该定时任务的截止时间 <= nanoTime ，则返回
    if (scheduledTask.deadlineNanos() <= nanoTime) {
        scheduledTaskQueue.remove();        return scheduledTask;
    }    return null;
}

“Netty NioEventLoop启动过程是怎样的”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注亿速云网站，小编将为大家输出更多高质量的实用文章！