NioEventLoopGroup继承层次结构图

2019独角兽企业重金招聘Python工程师标准>>>

NioEventLoopGroup继承层次结构图

Netty4的NioEventLoopGroup继承结构很复杂，为了理解它如何工作，我画了一张类似UML的图。但是这张图也很巨大，所以我做了以下处理：

• 将位于不同包中的类或接口用不同的颜色加以区分

• 接口名后面的括号里标注了大写字母I（Interface），抽象类名的后面标注了大写字母A（Abstract）

• 每个类或接口，只列出了我认为最重要的一个方法

 

EventExecutorGroup

首先从EventExecutorGroup开始，EventExecutorGroup是NioEventLoopGroup最上层的接口，再往上就是Java的地盘了：

 

从上面的图可以看出3点：

1. EventExecutorGroup接口继承了java.util.concurrent.ScheduledExecutorService接口，因此它可以调度执行task
2. EventExecutorGroup内部管理了n个EventExecutor，next()方法返回其中的一个
3. EventExecutor也是EventExecutorGroup（的子类）

想象一下，EventExecutorGroup就像一个BOSS，每当有活儿的时候，就派一个小弟（EventExecutor）去干：

 

AbstractEventExecutorGroup

AbstractEventExecutorGroup抽象类实现了ScheduledExecutorService接口，但大部分实现都只是调用next()拿到一个EventExecutor，然后调用EventExecutor的相应方法，例如submit()方法：

 

[java] view plain copy

 

1. public abstract class AbstractEventExecutorGroup implements EventExecutorGroup {  
2.   
3.     @Override  
4.     public Future<?> submit(Runnable task) {  
5.         return next().submit(task);  
6.     }  
7.     ...  
8. }  

 

 

 

MultithreadEventExecutorGroup

从类名来看，MultithreadEventExecutorGroup有并行（多线程）分配小弟去干活的能力，换句话说，每个小弟都工作在自己的线程中。从代码中也能看出这一点：

 

[java] view plain copy

 

1. public abstract class MultithreadEventExecutorGroup extends AbstractEventExecutorGroup {  
2.   
3.     private final EventExecutor[] children;  
4.     private final AtomicInteger childIndex = new AtomicInteger();  
5.     private final AtomicInteger terminatedChildren = new AtomicInteger();  
6.     private final Promise<?> terminationFuture = new DefaultPromise(GlobalEventExecutor.INSTANCE);  
7.   
8.     protected MultithreadEventExecutorGroup(int nThreads, ThreadFactory threadFactory, Object... args) {  
9.         ...  
10.         children = new SingleThreadEventExecutor[nThreads];  
11.         ...  
12.     }  
13.   
14.     ...  
15. }  

可以看出，MultithreadEventExecutorGroup的每一个小弟都是一个SingleThreadEventExecutor，而且小弟的数量在构造的时候就确定了，如下图所示：

 

 

 

从MultithreadEventExecutorGroup的next()方法可以看到，这个BOSS的小弟分配逻辑相当简单，无非就是轮流使唤：

 

[java] view plain copy

 

1. @Override  
2. public EventExecutor next() {  
3.     return children[Math.abs(childIndex.getAndIncrement() % children.length)];  
4. }  

注：这里调用了Math.abs()方法以防止childIndex溢出

 

 

MultithreadEventLoopGroup

MultithreadEventLoopGroup类实现了EventLoopGroup接口和register()方法：

 

[java] view plain copy

 

1. public abstract class MultithreadEventLoopGroup extends MultithreadEventExecutorGroup implements EventLoopGroup {  
2.     ...  
3.       
4.     @Override  
5.     public ChannelFuture register(Channel channel) {  
6.         return next().register(channel);  
7.     }  
8.   
9.     @Override  
10.     public ChannelFuture register(Channel channel, ChannelPromise promise) {  
11.         return next().register(channel, promise);  
12.     }  
13. }  

 

 

NioEventLoopGroup

最后是NioEventLoopGroup，这个BOSS的每一个小弟都是一个NioEventLoop。下面是完整的继承层次结构图：

 

结论

• NioEventLoopGroup实际上就是个线程池
• NioEventLoopGroup在后台启动了n个NioEventLoop来处理Channel事件
• 每一个NioEventLoop负责处理m个Channel
• NioEventLoopGroup从NioEventLoop数组里挨个取出NioEventLoop来处理Channel

转载于:https://my.oschina.net/u/1185936/blog/857051