if (eventLoop.inEventLoop()) {
    register0(promise);
} else {
    try {
        eventLoop.execute(new Runnable() {
            @Override
            public void run() {
                register0(promise);
            }
        });
    } catch (Throwable t) {
		...
    }
}

private void execute(Runnable task, boolean immediate) {
    boolean inEventLoop = inEventLoop();
    addTask(task);
    if (!inEventLoop) {
        startThread();
		...
    }
}

private void startThread() {
	if (state == ST_NOT_STARTED) {
		if (STATE_UPDATER.compareAndSet(this, ST_NOT_STARTED, ST_STARTED)) {
			...
			doStartThread();
			...
		}
	}
}

private void doStartThread() {
	...
	executor.execute(new Runnable() {
		@Override
		public void run() {
			...
			try {
				// 重要的地方
				SingleThreadEventExecutor.this.run();
				success = true;
			} catch (Throwable t) {
				logger.warn("Unexpected exception from an event executor: ", t);
			} finally {
				...
			}
		}
	});
}

@Override
protected void run() {
	int selectCnt = 0;
	for (;;) {
		try {
			int strategy;
			try {
				strategy = selectStrategy.calculateStrategy(selectNowSupplier, hasTasks());
				switch (strategy) {
				case SelectStrategy.CONTINUE:
					continue;
				case SelectStrategy.BUSY_WAIT:
				case SelectStrategy.SELECT: // 轮询 I/O 事件
					long curDeadlineNanos = nextScheduledTaskDeadlineNanos();
					if (curDeadlineNanos == -1L) {
						curDeadlineNanos = NONE; // nothing on the calendar
					}
					nextWakeupNanos.set(curDeadlineNanos);
					try {
						if (!hasTasks()) {
							strategy = select(curDeadlineNanos);
						}
					} finally {
						nextWakeupNanos.lazySet(AWAKE);
					}
					// fall through
				default:
				}
			} catch (IOException e) {
				...
			}

			selectCnt++;
			cancelledKeys = 0;
			needsToSelectAgain = false;
			final int ioRatio = this.ioRatio;
			boolean ranTasks;
			if (ioRatio == 100) {
				try {
					if (strategy > 0) {
						// 处理 I/O 事件
						processSelectedKeys();
					}
				} finally {
					// 处理所有任务
					ranTasks = runAllTasks();
				}
			} else if (strategy > 0) {
				final long ioStartTime = System.nanoTime();
				try {
					// 处理 I/O 事件
					processSelectedKeys();
				} finally {
					// // 处理完 I/O 事件，再处理异步任务队列
					final long ioTime = System.nanoTime() - ioStartTime;
					ranTasks = runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
				}
			} else {
				ranTasks = runAllTasks(0); // This will run the minimum number of tasks
			}

			...
		} catch (e) {
			...
		} finally {
			...
		}
	}
}

switch (strategy) {
case SelectStrategy.CONTINUE:
	continue;
case SelectStrategy.BUSY_WAIT:
case SelectStrategy.SELECT: // 轮询 I/O 事件
	long curDeadlineNanos = nextScheduledTaskDeadlineNanos();
	if (curDeadlineNanos == -1L) {
		curDeadlineNanos = NONE; // nothing on the calendar
	}
	nextWakeupNanos.set(curDeadlineNanos);
	try {
		if (!hasTasks()) {
			strategy = select(curDeadlineNanos);
		}
	} finally {
		// This update is just to help block unnecessary selector wakeups
        // so use of lazySet is ok (no race condition)
		nextWakeupNanos.lazySet(AWAKE);
	}
	// fall through
default:
}

// nextWakeupNanos is:
//    AWAKE            when EL is awake
//    NONE             when EL is waiting with no wakeup scheduled
//    other value T    when EL is waiting with wakeup scheduled at time T
private final AtomicLong nextWakeupNanos = new AtomicLong(AWAKE);

final class DefaultSelectStrategy implements SelectStrategy {
    @Override
    public int calculateStrategy(IntSupplier selectSupplier, boolean hasTasks) throws Exception {
        return hasTasks ? selectSupplier.get() : SelectStrategy.SELECT;
    }
}

// NioEventLoop 
private final IntSupplier selectNowSupplier = new IntSupplier() {
	public int get() throws Exception {
		return NioEventLoop.this.selectNow();
	}
};

int selectNow() throws IOException {
	return this.selector.selectNow();
}

private int select(long deadlineNanos) throws IOException {
    if (deadlineNanos == NONE) {
        return selector.select();
    }
    // Timeout will only be 0 if deadline is within 5 microsecs
    // 判断是否超过5微妙，如果超过说明当前任务队列中有定时任务需要立刻执行，执行延时select，否则就执行selectNow()
    long timeoutMillis = deadlineToDelayNanos(deadlineNanos + 995000L) / 1000000L;
    return timeoutMillis <= 0 ? selector.selectNow() : selector.select(timeoutMillis);
}

private void processSelectedKeys() {
    if (selectedKeys != null) {
        processSelectedKeysOptimized();
    } else {
        processSelectedKeysPlain(selector.selectedKeys());
    }
}

private void processSelectedKeysPlain(Set<SelectionKey> selectedKeys) {
	...
    Iterator<SelectionKey> i = selectedKeys.iterator();
    for (;;) {
        final SelectionKey k = i.next();
        // SelectionKey 上面可以挂载 attachment
        final Object a = k.attachment();
        i.remove();
		//根据 attachment 属性可以判断 SelectionKey 的类型,AbstractNioChannel 类型由 Netty 框架负责处理
        if (a instanceof AbstractNioChannel) {
            processSelectedKey(k, (AbstractNioChannel) a);
        } else {
            @SuppressWarnings("unchecked")
            // NioTask 是用户自定义的 task
            NioTask<SelectableChannel> task = (NioTask<SelectableChannel>) a;
            processSelectedKey(k, task);
        }
		...
    }
}

private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
    final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();
    // 检查 Key 是否合法
    if (!k.isValid()) {
        final EventLoop eventLoop;
		...
		
        if (eventLoop == this) {
            // close the channel if the key is not valid anymore
            // key不合法，关闭连接
            unsafe.close(unsafe.voidPromise());
        }
        return;
    }

    try {
        int readyOps = k.readyOps();
        // 处理连接事件
        if ((readyOps & SelectionKey.OP_CONNECT) != 0) {
            int ops = k.interestOps();
            ops &= ~SelectionKey.OP_CONNECT;
            k.interestOps(ops);

            unsafe.finishConnect();
        }

        // 处理可写事件
        if ((readyOps & SelectionKey.OP_WRITE) != 0) {
            ch.unsafe().forceFlush();
        }

        // 处理可读事件
        if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
            unsafe.read();
        }
    } catch (CancelledKeyException ignored) {
        unsafe.close(unsafe.voidPromise());
    }
}

private void execute(Runnable task, boolean immediate) {
    boolean inEventLoop = inEventLoop();
    // 将任务添加到了 taskQueue
    addTask(task);
	...

    if (!addTaskWakesUp && immediate) {
        wakeup(inEventLoop);
    }
}

protected boolean runAllTasks(long timeoutNanos) {
	// 合并定时任务到普通任务队列
    fetchFromScheduledTaskQueue();
    // 从普通任务队列中取出任务并处理
    Runnable task = pollTask();
    if (task == null) {
        afterRunningAllTasks();
        return false;
    }
	// 计算任务处理的超时时间
    final long deadline = timeoutNanos > 0 ? ScheduledFutureTask.nanoTime() + timeoutNanos : 0;
    long runTasks = 0;
    long lastExecutionTime;
    for (;;) {
    	// 执行任务
        safeExecute(task);

        runTasks ++;

        // 每执行 64 个任务检查一下是否超时
        if ((runTasks & 0x3F) == 0) {
            lastExecutionTime = ScheduledFutureTask.nanoTime();
            if (lastExecutionTime >= deadline) {
                break;
            }
        }
		// 继续取出下一个任务
        task = pollTask();
        if (task == null) {
            lastExecutionTime = ScheduledFutureTask.nanoTime();
            break;
        }
    }
	// 收尾工作，把尾部队列 tailTasks 里的任务以此取出执行一遍
    afterRunningAllTasks();
    this.lastExecutionTime = lastExecutionTime;
    return true;
}