概述
我们知道netty的启动是需要实力话两个EventLoopGroup
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
EventLoopGroup 组
EventLoopGroup 继承EventExecutorGroup , EventExecutorGroup 就是一个线程池,继承了线程包中的ScheduledExecutorService,我们都知道,改接口有定时执行的功能
它本身继承了4个重要接口，以及它们各自的功能：
- Iterable:迭代器接口，返回一个迭代器。说明已经具备了Group的管理或者容器功能。
- Executor:具备了提交任务的能力。
- ExecutorService:具备了线程池的能力。
- ScheduledExecutorService:具备了执行调度任务的能力。
这4种能力不多说，都是JDK本身提供的，我们杰西莱看一下，它本身定义了哪些方法呢？如下图：
它优化了JDK提供的关于中断的方法：标记过时（shutdown，shutdownNow），并且新加了几个方法
boolean isShuttingDown();
Future<?> shutdownGracefully();
Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit);
增加了一个中断状态监听的方法
Future<?> terminationFuture()。注意这个Future是netty的.
可以在这个future上面增加一些监听器（addListener），然后当中断的时候就会触发。
增加了next方法。返回的是由它管理的EventExecutor。这个组的味道已经出现了。这个也是后面实现轮询内部成员的一个关键方法。
这个接口的功能就是：线程池，管理一组EventExecutor，调度任务，中断监听。
EventLoopGroup 核心方法
public interface EventLoopGroup extends EventExecutorGroup {
/**
* Return the next {@link EventLoop} to use
* next 方法是把指针指向下一个线程,因为netty基于NIO,NIO之所以非阻塞,是因为用到了ForkJoinPool这种线程池,这种线程池
* 支持线程任务分发然后合并,任务盗取等任务,有兴趣的同学可以去专门了解下java的并非变成ForkJoinPool
* next 就是本线程线程绝对该任务可以发给下一个线程处理,这个过程就是netty的事件循环组的意义
*/
@Override
EventLoop next();
/**
* Register a {@link Channel} with this {@link EventLoop}. The returned {@link ChannelFuture}
* will get notified once the registration was complete.
*/
ChannelFuture register(Channel channel);
/**
* Register a {@link Channel} with this {@link EventLoop} using a {@link ChannelFuture}. The passed
* {@link ChannelFuture} will get notified once the registration was complete and also will get returned.
*/
ChannelFuture register(ChannelPromise promise);
/**
* Register a {@link Channel} with this {@link EventLoop}. The passed {@link ChannelFuture}
* will get notified once the registration was complete and also will get returned.
*
* @deprecated Use {@link #register(ChannelPromise)} instead.
*/
@Deprecated
ChannelFuture register(Channel channel, ChannelPromise promise);
}
EventExecutorGroup
这个接口负责提供EventExecutor (事件执行器) ,用什么来提供,用next方法提供(指向下一个线程去执行),并且可以优雅的关闭.
AbstractEventExecutorGroup
这个类没有任何的实现，仅仅只是把所有的提交任务的方法做了一下默认实现：就是调用一些next()方法轮询出来一个Executor然后去执行，比如：
@Override
public void execute(Runnable command) {
next().execute(command);
}
其它的所有方法都没有实现，也确实挺抽象的。
不过这个抽象类的作用还是非常大的，之前在分析组和成员关系的时候，组也具备了一些成员关系的功能，但是它的执行就是通过成员去完成的，而且这些功能本身也确实不需要组去关心的。而netty就是把这些功能放在了这个类里面，也放的特别合适，它没有实现任何有关于的组的管理功能，实际上就是交给子类去完成了，而子类在实现管理功能的时候，也就不需要关心这些功能了（提交任务），父类都已经实现了。
MultithreadEventExecutorGroup
听名字就可以听出来一些味道了：多线程事件执行器组。
3个关键词：多线程，事件执行器，组。
这个里面才是真正实现了组的管理功能，看一下它内部所有的属性和方法：
private final EventExecutor[] children;
private final Set<EventExecutor> readonlyChildren;
private final AtomicInteger terminatedChildren;
private final Promise<?> terminationFuture;
private final EventExecutorChooser chooser;
先看一下内部属性吧：
- EventExecutor[] children：固定大小的EventExecutor数组，构造器里面会根据大小全部初始化成员。
- EventExecutorChooser chooser：成员轮询器。虽然有两种实现，但其实都是按照（0，1,2，3，…，n-1）的顺序来的。只不过当大小是2的幂的时候，采用了一下位的和（&）运算，会稍微快一些。这个就是next方法的实现。
- terminationFuture：中断的一个Future，可以用来监听中断事件。
- readonlyChildren：用一个不可写的集合来做迭代器用。
- terminatedChildren：原子int，用来标记当前有多少个成员已经被中断了，当所有的都被中断的时候，就会触发中断事件。
这个类比较核心的就是它的构造器了，至于其它的关于中断的方法，基本上也都是循环中断所有的成员，不是特别复杂。当然还有一个创建成员的抽象方法，不过也是和构造器相呼应的。
关于它的构造器和一个抽象方法，我觉得也是比较有趣的点。
-
它的所有的构造器都是protected的，说明不是对外开放的，由子类去调用的。
-
最有趣的在于构造器的最后一个参数居然是：Object… args。在构造器里面，这种写法确实还是比较少见的。
-
这个类仅有一个抽象方法：
protected abstract EventExecutor newChild(Executor executor, Object... args) throws Exception;
就是在初始化成员的时候需要调用的方法，而且它的最后一个参数也是 Object… args。其实构造器的对象数组的入参和这个入参是相呼应的，就是同一个
-
这个构造器当时在定义的时候，开发人员估计费了不少的心思啊，哈哈。
-
那为什么要这样写呢？那肯定是为了复用，复用这些组的管理功能。它所管理的Executor到底需要哪些参数，以及如何来创建。它不关心，它也没法关心；所以留到了子类，同时它希望对于具体的子类而已，那个对象数组不能暴露给框架的使用人员，希望他们具体化，不能这么抽象的使用，所以构造器全部protected。
DefaultEventExecutorGroup
这个类非常简单，提供了3个构造器，实现了newChild方法，并且明确了成员就是DefaultEventExecutor。
当我学习到这边的时候，就基本非常明确了，它就是一个线程池，我第一个想到的就是和ThreadPoolExecutor进行比较，之前的文章以及比较过了。但是在比较之前，想了一下，我好像还并不知道任务是怎么执行的，也就是EventExecutor的具体实现了。
EventExecutor 成员
事件执行器EventExecutor 事件执行器,也是一个借口,其中一个抽象类
AbstractScheduledEventExecutor ,支持了scheuduling(线程的定时调度,或者定时执行)
SingleThreadEventExecutor 继承AbstractScheduledEventExecutor ,实现OrderedEventExecutor接口,任务可以顺心执行,
其实我们看源码发现OrderedEventExecutor 就是一个空的接口,但是怎么保证线程能按照顺序执行,‘
private final Queue taskQueue; 定义了一个taskQueue,
netty提供的一个默认实现DefaultEventExecutor ,继承了SingleThreadEventExecutor, 里面的任务执行方法run
它继承了EventExecutorGroup，说明它也拥有上面说的所有功能。
重点关注一下，它新定义的方法吧：
它基本上新定义了3类接口：
- parent():返回父节点。也反映了它被EventExecutorGroup管理的特性。
- inEventLoop():判断当前线程是不是当前EventExecutor所关联的事件循环的线程。非常重要的方法，好多地方都会用到。因为在后续的提交任务的时候，有可能是事件循环的线程（这个就是提交的任务在执行过程当中又提交了新的任务），有可能是其它线程。然后可能需要做一些线程安全方面的工作。
- 创建Promise,或者Future的方法。这个我没有用过，但是也了解了一些，简单说一下，可能不太对。这两种对象都代表的是异步执行的结果，前者相对于后者具备了写的功能，后者只可读。但是他们都具备结束然后事件通知的能力，那么谁来通知呢？就是当前EventExector所关联的线程去通知。也就是通过它创建的，都会用它的关联线程去执行通知任务。但是具体的应用场景还不太清楚。
以后就是它比Group多出来的方法，一方面体现了它是成员角色，另一方面它也可以做额外的事情。从下面开始，也就没有接口定义了，都是具体的类了。
@Override
protected void run() {
for (;;) {
Runnable task = takeTask();
if (task != null) {
task.run();
updateLastExecutionTime();
}
if (confirmShutdown()) {
break;
}
}
}
执行方式,循环一直跑,只要taskTask()里面有任务,就拿出来执行,如果confirmShutdown()就跳出循环,这个地方大家一定理解是单线程,因为是run方法
AbstractEventExecutor
这个类一方面实现了EventExecutor，另一方也继承了JDK提供的AbstractExecutorService。后面这个类更多的是提供提交一些任务的默认实现，也没有做具体的业务实现。
AbstractEventExecutor它本身也没有做太多事情，只是把接口和抽象类整合在了一起。稍微梳理一下吧：
parent:定义了父对象。
selfCollection:返回一个属于自己的迭代器。
promise,future的方法都做了实现，如下：
关于定时任务的，都直接抛了异常，不支持。
提供了一个EventExecutorGroup的一个构造器。
AbstractScheduledEventExecutor
看这个名字基本也能猜出来，它实现了调度任务：
内部有一个优先级队列，最早执行的会放在队首，每次提交任务的时候会进行调整。它这个不是线程安全的队列。因此它在添加调度任务的时候，如果不是事件循环线程的话，会提交一个新的普通任务取提交任务，保证线程安全：
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 {
lazyExecute(task);
// Second hook after scheduling to facilitate race-avoidance
if (afterScheduledTaskSubmitted(deadlineNanos)) {
execute(WAKEUP_TASK);
}
}
}
return task;
}
所有被提交的调度任务都会被封装成ScheduledFutureTask，这个对象里面有几个关键点：
当这个类被内存加载的时候，会生成当前时间的一个纳秒时间戳。以后所有的时间计算都会以它作为开始时间的标准，比如获取当前纳米戳=获取当前纳秒时间戳的然后减去开始时间就是当前时间：
private static final long START_TIME = System.nanoTime();
static long nanoTime() {
return System.nanoTime() - START_TIME;
}
-
deadlineNanos：这个任务应该被执行的纳秒时间戳。都是通过比较这个属性值来判断当前任务是不是到时间去执行了。
-
periodNanos：调度任务的执行周期。为0的话，代表只执行一次。否则，就认为是周期不断执行的任务，间隔就是periodNanos。
-
关键在于它的run方法，解决了如何执行周期任务。当一个周期任务执行完了，它会把periodNanos加到deadlineNanos上面取，作为新的执行时间，然后重新加入队列。然后就可以再执行了：
@Override
public void run() {
assert executor().inEventLoop();
try {
if (delayNanos() > 0L) {
// Not yet expired, need to add or remove from queue
if (isCancelled()) {
scheduledExecutor().scheduledTaskQueue().removeTyped(this);
} else {
scheduledExecutor().scheduleFromEventLoop(this);
}
return;
}
if (periodNanos == 0) {
if (setUncancellableInternal()) {
V result = runTask();
setSuccessInternal(result);
}
} else {
// check if is done as it may was cancelled
if (!isCancelled()) {
runTask();
if (!executor().isShutdown()) {
if (periodNanos > 0) {
deadlineNanos += periodNanos;
} else {
deadlineNanos = nanoTime() - periodNanos;
}
if (!isCancelled()) {
scheduledExecutor().scheduledTaskQueue().add(this);
}
}
}
}
} catch (Throwable cause) {
setFailureInternal(cause);
}
}
- 同时它也提供了一些取出到了执行时间任务的一些方法，供子类使用。
SingleThreadEventExecutor
单线程事件执行器，意思以及很明确了，用一个线程去执行所有的事件。
这个类的属性和方法有点多，生成的图不好看，IDEA也不能删除其中几个。那就没有图了，调几个重要的：
private final Queue<Runnable> taskQueue;
private volatile Thread thread;
private final boolean addTaskWakesUp;
private final int maxPendingTasks;
简单说一下这几个属性吧：
- taskQueue:任务队列，所有提交的任务会执行扔到这个队列里面。注意它的定义并不是阻塞队列。但是它创建的时候，提供的默认实现就是阻塞队列，并且它提供的一个内部方法takeTask()，取任务的时候还强制要求必须是阻塞队列，否则就抛异常。刚开始还挺郁闷的，想不明白。最后发现创建队列的方法被NIOEventLoop给重写了，它那边提供的是一个无锁高性能队列MPSC（多生茶这，单消费者，这就是它的消费模型）队列，这个并不是阻塞队列。这或许解释得通？
- thread：事件循环的线程。会在线程启动以后赋值这个变量，它是用Executor启动的，而不是直接一个线程。
- addTaskWakesUp：如果为true，意味着：当且仅当执行addTask(Runnable)方法的时候，会唤醒执行器的线程。我对这个变量没有搞太明白，它这边提供的构造器默认是true，而EventLoop那边变成了false，而且我很明确它为false的时候提交一个新任务进来才可以唤醒正在阻塞轮询的线程。它说明中的addTask方法，也是仅仅是提交任务的时候会去触发：
@Override
public void execute(Runnable task) {
if (task == null) {
throw new NullPointerException("task");
}
boolean inEventLoop = inEventLoop();
if (inEventLoop) {
addTask(task);
} else {
startThread();
addTask(task);
if (isShutdown() && removeTask(task)) {
reject();
}
}
if (!addTaskWakesUp && wakesUpForTask(task)) {
wakeup(inEventLoop);
}
}
重点可以看一下后面两行，它必须为true，才会去执行wakeUp方法。所以对于它的描述，实现是看不明白。不解释了，有明白的可以分享一下。
-
maxPendingTasks：队列的最大容量。
从功能上来讲，这个类主要做了这么几件事情： -
任务队的创建。
-
循环线程的启动，当提交第一个任务的时候就会启动线程：
private void startThread() {
if (state == ST_NOT_STARTED) {
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() {
assert thread == null;
executor.execute(new Runnable() {
@Override
public void run() {
thread = Thread.currentThread();
if (interrupted) {
thread.interrupt();
}
boolean success = false;
updateLastExecutionTime();
try {
SingleThreadEventExecutor.this.run();
success = true;
} catch (Throwable t) {
logger.warn("Unexpected exception from an event executor: ", t);
}
//其它的省略一下
}
});
}
启动以后，它重点就做了一个事情,执行run方法。这是个抽象方法。也就是真正的循环体这边也没有实现。
任务的提交。实现了execute方法，这也是非常关键的方法。
提供了一些从队列里面取任务的方法，供子类用，毕竟它定义队列成private了，比如:
- Runnable pollTask()
- Runnable pollTaskFrom(Queue taskQueue)
- Runnable takeTask()
- boolean fetchFromScheduledTaskQueue()
- Runnable peekTask()
还提供了一些执行任务的方法，比如： - boolean runAllTasks()
- runAllTasksFrom(Queue taskQueue)
- runAllTasks(long timeoutNanos)
它的职责就这些，该做的都做了，但是我要怎么循环取任务呀，好像也没说。这就剩下最关键的一个方法run了。它也是EventLoop最大的区别了。
DefaultEventExecutor
非常简单不分析了
EventLoop的运行机制
- EventExecutorGroup里面包含了n个EventExecutor，n需要在初始化的时候就指定。
- 在EventExecutorGroup提交的任务，它都会选择组内一个EventExecutor（顺序轮询选择）去执行，所以运行机制的重点是EventExecutor。
- EventExecutor内部会和一个线程进行关联，当提交第一个任务的时候，线程启动并且不停运行，除非外界执行关闭操作。
- EventExecutor内部有两个队列：taskQueue和scheduleTaskQueue，前者是一个阻塞队列，存储提交的普通task（用execute或者submit方法提交的）；后者是一个优先级队列（线程不安全），存储的是调度任务（用schedule方法提交的），它会把最早应该执行的任务放在队首，保证peek出来的一定是队列优先级最高的。
- 提交普通task的时候，直接加进队列；提交定时任务的时候，当前线程是关联线程的话，加到调度队列中，否则提交一个普通task，task的内容就是：把调度任务加入调度队列中。
- 关联的线程一直在循环做一件事情：取任务，然后执行。
- 取任务的过程，图中应该比较清晰，它的具体代码实现是在类SingleThreadEventExecutor的takeTask()方法，可以结合在一起看。
组和成员之间的关系有如下特点：
- 组拥有成员的一部分功能
- 其中一些功能的具体实现需要依靠成员去完成，比如提交任务
- 其中一些功能与成员表示的含义层次不同，比如关闭等方法。
- 成员拥有组的所有功能
- 成员比组多一些额外的功能
- 基于如上特点，才有了EventExecutorGroup与EventExecutor的继承关系。
- 当组的功能大于成员，并且放在成员上特别不合适的时候（比如类似于next和iterator这些的，成员方法实现这些方法的时候，直接返回的就是本身），继承关系是不是就应该反过来了，或许吧，还没有见过。
和线程池一个对比
线程池就不多说大家比较熟悉,可以查看这个线程池文章《08_线程池,居然帮助帮朋友面试过了》
EventLoopGroup和EventLoop
NIOEventLoop
创建过程
图看不清看下面的连接:
https://www.processon.com/view/link/62b698da5653bb10419639fb
扫一扫
864
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
