netty5笔记-线程模型2-EventLoopGroup

绝地灬酷狼 2022-05-28 01:38 190阅读 0赞

阅读本文之前，你需要对java的线程池有一定的了解，因为这里不会过多的讲解。

今天我们主要的任务就是看下netty中一个非常重要的类EventLoop，通过这系列文章，你应该了解EventLoop适用的场景，不会滥用它而导致你的应用缓慢。Netty使用了典型的Reactor模型结构，这其中一个很重要的角色就是EventLoop，它使用循环的方式来处理IO或者其他事件。

![Center][]

上图是EventLoop的接口继承关系，其中Executor、ExecutorService、ScheduledExecutorService是java提供的线程池管理接口：

ScheduledExecutorService：提供执行计划任务的接口；

EventExecutorGroup：提供管理EventExecutor的能力，他通过next()来为任务分配执行线程，同时也提供了shutdownGracefully这一优雅下线的接口；

<table style="width:780px;color:rgb(69,69,69);font-size:16px;background-color:rgb(255,255,255);"> 
 <tbody> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </tbody> 
 <tbody> 
  <tr> 
   <td>shutdownGraceFully</td> 
   <td>优雅关闭（何为优化关闭后面会介绍）</td> 
  </tr> 
  <tr> 
   <td>isShuttingDown</td> 
   <td>其管理的所有EventExecutor是否关闭</td> 
  </tr> 
  <tr> 
   <td>terminationFuture</td> 
   <td>返回接收该线程池彻底关闭事件的Future</td> 
  </tr> 
  <tr> 
   <td>children</td> 
   <td>含所有管理的EventExecutor</td> 
  </tr> 
  <tr> 
   <td>next</td> 
   <td>通过该方法来为任务分配一个EventExecutor</td> 
  </tr> 
 </tbody> 
</table>

EventExecutor：实际的事件执行者

<table style="width:780px;color:rgb(69,69,69);font-size:16px;background-color:rgb(255,255,255);"> 
 <tbody> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </tbody> 
 <tbody> 
  <tr> 
   <td>parent</td> 
   <td>管理它的EventExecutorGroup</td> 
  </tr> 
  <tr> 
   <td>isEventLoop</td> 
   <td>当前线程与EventExecutor的执行线程是否是同一个线程，如果是则此处返回true</td> 
  </tr> 
  <tr> 
   <td>newPromise</td> 
   <td>创建一个Promise，由该EventExecutor来执行Promise中的listener</td> 
  </tr> 
 </tbody> 
</table>

EventLoopGroup: EventLoopGroup和EventLoop的关系与EventExecutorGroup和EventExecutor的关系类似

<table style="width:780px;color:rgb(69,69,69);font-size:16px;background-color:rgb(255,255,255);"> 
 <tbody> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </tbody> 
 <tbody> 
  <tr> 
   <td>register</td> 
   <td>将channel注册到该EventLoopGroup，注册后EventLoop会负责该channel的相关io事件</td> 
  </tr> 
 </tbody> 
</table>

EventLoop：处理所有的IO操作。EventLoop继承了EventLoopGroup接口，可以被当做一个single的线程池看到（虽然模式差不多，但其实和java的single线程池区别很大）。

我们找一个最常用的EventLoop实现类来介绍：NioEventLoop。介绍它之前我们得先介绍NioEventLoopGroup，一个连接被它分配到对应的NioEventLoop并进行一系列的后续操作。先看看NioEventLoopGroup的构造函数，最终调用的是下面这个构造方法：

**\[java\]**  [view plain][]  [copy][view plain]

1.         private MultithreadEventExecutorGroup(int nEventExecutors,  
2.                                            Executor executor,  
3.                                            boolean shutdownExecutor,  
4.                                            Object... args) \{  
5.         if (nEventExecutors <= 0) \{  
6.              throw new IllegalArgumentException(  
7.                      String.format("nEventExecutors: %d (expected: > 0)", nEventExecutors));  
8.          \}  
9.    
10.         if (executor == null) \{  
11.             executor = newDefaultExecutorService(nEventExecutors);  
12.             shutdownExecutor = true;  
13.         \}  
14.   
15.         // 根据nEventExecutors确定EventExecutor的数量  
16.         children = new EventExecutor\[nEventExecutors\];  
17.         // 用了两种不同的方式来为一个任务分配EventExecutor,。  
18.         // 两种实现结果是相同的，但是第一种利用的位运算，相对效率更高点。。。  
19.         // 具体的实现是从children的第一个开始获取，从0->size-1依次取child，到达最后一个后回到第一个child，最终形成一个环形数组。  
20.         if (isPowerOfTwo(children.length)) \{  
21.             chooser = new PowerOfTwoEventExecutorChooser();  
22.         \} else \{  
23.             chooser = new GenericEventExecutorChooser();  
24.         \}  
25.   
26.         // 开始初始化每个EventExecutor  
27.         for (int i = 0; i < nEventExecutors; i ++) \{  
28.             boolean success = false;  
29.             try \{  
30.                 // 实际的初始化由子类自己实现，如NioEventLoopGroup的实现为：  
31.                 // return new NioEventLoop(this, executor, (SelectorProvider) args\[0\]);  
32.                 children\[i\] = newChild(executor, args);  
33.                 success = true;  
34.             \} catch (Exception e) \{  
35.                 // TODO: Think about if this is a good exception type  
36.                 throw new IllegalStateException("failed to create a child event loop", e);  
37.             \} finally \{  
38.                 // 如果初始化的过程中发生异常，则将初始化好的EventExecutor全部关闭  
39.                 if (!success) \{  
40.                     for (int j = 0; j < i; j ++) \{  
41.                         children\[j\].shutdownGracefully();  
42.                     \}  
43.   
44.                     for (int j = 0; j < i; j ++) \{  
45.                         EventExecutor e = children\[j\];  
46.                         // 等待关闭完成  
47.                         try \{  
48.                             while (!e.isTerminated()) \{  
49.                                 e.awaitTermination(Integer.MAX\_VALUE, TimeUnit.SECONDS);  
50.                             \}  
51.                         \} catch (InterruptedException interrupted) \{  
52.                             // Let the caller handle the interruption.  
53.                             Thread.currentThread().interrupt();  
54.                             break;  
55.                         \}  
56.                     \}  
57.                 \}  
58.             \}  
59.         \}  
60.   
61.         final boolean shutdownExecutor0 = shutdownExecutor;  
62.         final Executor executor0 = executor;  
63.         final FutureListener<Object> terminationListener = new FutureListener<Object>() \{  
64.             @Override  
65.             public void operationComplete(Future<Object> future) throws Exception \{  
66.                 // 最后一个关闭完成则标记future完成  
67.                 if (terminatedChildren.incrementAndGet() == children.length) \{  
68.                     terminationFuture.setSuccess(null);  
69.                     if (shutdownExecutor0) \{  
70.                         // This cast is correct because shutdownExecutor0 is only try if  
71.                         // executor0 is of type ExecutorService.  
72.                         ((ExecutorService) executor0).shutdown();  
73.                     \}  
74.                 \}  
75.             \}  
76.         \};  
77.   
78.         // 下面的代码比较简单，不过多介绍  
79.         xxxxxxxxxxxxxxxxxxxxxxxx  
80.     \}  
81.   
82.     // 看看这两个实现类的差异，这效率扣得不要不要的啊！  
83.     private final class PowerOfTwoEventExecutorChooser implements EventExecutorChooser \{  
84.         @Override  
85.         public EventExecutor next() \{  
86.             return children\[childIndex.getAndIncrement() & children.length - 1\];  
87.         \}  
88.     \}  
89.   
90.     private final class GenericEventExecutorChooser implements EventExecutorChooser \{  
91.         @Override  
92.         public EventExecutor next() \{  
93.             return children\[Math.abs(childIndex.getAndIncrement() % children.length)\];  
94.         \}  
95.     \}

我们在使用NioEventGroupLoop的时候，一般都是直接使用默认构造方法，此时第一个参数nEventExecutors=cpu核数 x 2。NioEventGroupLoop中有很大部分的io操作，这个默认值比较靠谱，不用用户再去修改。

**\[java\]**  [view plain][]  [copy][view plain]

1.  private static final int DEFAULT\_EVENT\_LOOP\_THREADS;  
2.    
3.  static \{  
4.      DEFAULT\_EVENT\_LOOP\_THREADS = Math.max(1, SystemPropertyUtil.getInt(  
5.              "io.netty.eventLoopThreads", Runtime.getRuntime().availableProcessors() \* 2));  
6.    
7.      if (logger.isDebugEnabled()) \{  
8.          logger.debug("-Dio.netty.eventLoopThreads: \{\}", DEFAULT\_EVENT\_LOOP\_THREADS);  
9.      \}  
10. \}

构造方法的第二个参数executor，它是执行EventExecutor中的任务的实际线程池。默认使用的是netty实现的ForkJoinPool（比较复杂，有空再回过头来分析）。可以看出NioEventLoop本身是不负责线程的创建销毁的，他把执行逻辑封装在Runnable中交给executor处理，这里的模型和netty4已经不太一样，4的EventLoop对应一个固定线程，而5的EventLoop并未固定到一个线程。这也是我困惑的地方，executor的线程数与EventLoop个数相同，能保证每个EventLoop都有线程去执行，但是每个EventLoop不再是固定的Thread了，它带来的问题是一些ThreadLocal的cache可能会失效。不知道为何会这样设计，先在这留个疑问吧，等release版本出来了再看看。

构造方法的最后一个参数args\[0\]=SelectorProvider.provider(); SelectorProvider根据不同的操作系统创建出对应的provider，如linux下创建的是sun.nio.ch.EPollSelectorProvider。该参数在NioEventLoop初始化的时候被传入，用于创建Selector（这里有一篇[Selector的介绍][Selector]）。

往EventLoopGroup中提交一个任务，实际上就是交给其child(即EventLoop)处理：

**\[java\]**  [view plain][]  [copy][view plain]

1.      public <T> Future<T> submit(Callable<T> task) \{  
2.          return next().submit(task);  
3.      \}  
4.      public EventExecutor next() \{  
5.          return chooser.next();  
6.      \}  
7.    
8.          // next方法的其中一个实现，这样可以保证每个child中处理的连接数基本相同  
9.          public EventExecutor next() \{  
10.             return children\[childIndex.getAndIncrement() & children.length - 1\];  
11.         \}

Event LoopGroup提供了一个注册Channel(表示一个连接）的接口：

**\[java\]**  [view plain][]  [copy][view plain]

1.  public ChannelFuture register(Channel channel) \{  
2.      return next().register(channel);  
3.  \}

就一句代码，背后隐藏的信息却非常重要：连接在注册时就绑定了一个固定的EventLoop，绑定的方式为将channel注册到EventLoop所在的Selector，此连接的读写及其他相关操作（如编码解码、超时管理）都交给了这个EventLoop；因此正常情况下一个连接涉及到的方法（如读/写/编解码/超时管理）都在一个EventLoop中进行，意味着所有这些操作都是线程安全的。还记得netty3吗，超时管理是交给HashedWheelTimer进行管理的，由于超时任务和读写任务是在不同的线程执行，如果超时的同时读入或写出数据也到达，可能会产生非预期的效果。然而由于线程模型的修改，虽然能保证线程安全，但却不再保证这些操作都在一个线程里，这种情况下ThreadLocal的相关功能可能会失效。

这里又引申出一个问题，由于一个连接是和一个EventLoop绑定的，如果EventLoop中存在一个执行时间很长的任务，那该EventLoop后续的所有连接都会被hold住得不到处理，因此应用不要在handler中添加会阻塞或者执行时间很长的操作。网上看到很多文章说是把业务操作放到io线程里去执行，导致系统处理慢甚至挂掉，希望看了这篇文章的同学不要犯同样的错。

**\[java\]**  [view plain][]  [copy][view plain]

1.  /\*\* 
2.    \* 设置I/O操作在EventLoop中占的时间比，(0-100)，默认为50，即执行I/O的时间与非I/O的时间相同 
3.    \*/  
4.   public void setIoRatio(int ioRatio) \{  
5.       for (EventExecutor e: children()) \{  
6.           ((NioEventLoop) e).setIoRatio(ioRatio);  
7.       \}  
8.   \}  
9.    
10.  /\*\* 
11.   \* 当epoll占用100%时（早期jdk的bug，不知道现在彻底处理了没），使用此方法来用新的Selector替代老的EventLoop中的Selector 
12.   \*/  
13.  public void rebuildSelectors() \{  
14.      for (EventExecutor e: children()) \{  
15.          ((NioEventLoop) e).rebuildSelector();  
16.      \}  
17.  \}

好了，到这里NioEventLoopGroup的基本功能就这么多，实现不复杂，但初始化使用的几个默认值需要关注。看了这里你是不是大概明白了[上一篇文章][Link 1]中那幅图的意思了。不过我还是准备强调下这几点（重要的事情多说一遍）：

1、NioEventLoopGroup下默认的NioEventLoop个数为cpu核数 \* 2，因为有很多的io处理；

2、NioEventLoop和java的single线程池在5里差异变大了，它本身不负责线程的创建销毁，而是由外部传入的线程池管理。后面的文章会介绍，他的处理逻辑都封装到Runnable中了;

3、channel和EventLoop是绑定的，即一旦连接被分配到EventLoop，其相关的I/O、编解码、超时处理都在同一个EventLoop中，这样可以确保这些操作都是线程安全的，而不像netty3中可能会出现非预期的执行结果。但和netty4不同的是netty5中并不能保证一个连接的所有操作在同一个线程中，因此和ThreadLocal相关的功能可能会失效（比如内存池的PoolThreadCache在这种情况下无法达到最佳效果)。

补充：

关于executor的引入的一个讨论：https://github.com/netty/netty/issues/2250，从这个问题中，我们可以大概了解为什么netty5要这么改：

1、希望能留给用户更多空间来定制化I/O的执行

2、希望用到fork/jion框架的stealing机制，避免因个别连接问题导致整个任务链阻塞。目前还在思考如何修改netty的架构来达到这个目的。

3、目前的默认实现能够保证效率和之前的一样，能保证线程安全，但内存池之类的效率受到了挑战，这个也是这次改动需要考虑的。

如果最终这个改动成功，那么netty可能的变化：

1、整个线程模型改变；

2、用户可以自定义线程池的实现；

3、内存池的相应修改；

4、一个连接的阻塞不会影响其他连接（如果大量连接阻塞就没办法了）；

5、有可能可以直接在netty的线程池中执行长任务（执行时间长），而不用对业务处理单独开连接池。

6、一个连接的操作会保证线程安全，但不一定是在同一个线程中执行，因此如果有在I/O handler中使用ThreadLocal的同学，可以提前想下应对方案。

...等等...

想想有点小激动，不过挑战挺多的，是一次很大的底层改动。仰望大神！(遗憾的是5.0已经被干掉了！！！见 https://github.com/netty/netty/issues/4466)

[Center]: /images/20220528/855e4c5142144a0f939f0855ba845e74.png
[view plain]: https://blog.csdn.net/youaremoon/article/details/50282353#
[Selector]: http://ifeve.com/selectors/
[Link 1]: http://blog.csdn.net/youaremoon/article/details/50279965

发表评论取消回复

表情：

评论列表（有 0 条评论，190人围观）

还没有评论，来说两句吧...

相关阅读

相关 netty学习笔记05 - 线程模型

线程模型基本介绍 > 1. 不同的线程模式，对程序的性能有很大影响，为了搞清Netty 线程模式，我们来系统的讲解下各个线程模式，最后看看Netty 线程模型有什

古城微笑少年丶/ 2023年07月05日 11:57/ 0 赞/ 14 阅读

相关 Netty线程模型

来谈谈Netty的线程模型，因为其模型实现与Netty的异步处理能力紧密相关，其线程模型如图所示。 ![watermark_type_ZmFuZ3poZW5naGVpdGk

Dear 丶/ 2022年12月22日 00:45/ 0 赞/ 146 阅读

相关 Netty 线程模型

1. 前言前面几节分别讲解了 Reactor 的三种线程模型，都知道主从 Reactor 多线程模型的性能非常的好，那么 Netty 是否就是使用主从 Reactor

迈不过友情╰/ 2022年10月25日 12:57/ 0 赞/ 190 阅读

相关 [netty源码分析]--EventLoopGroup与EventLoop 分析netty的线程模型

> netty核心类源码解析：分析netty的运行机制 > > 1. EventLoopGroup与EventLoop解析：分析netty的线程模型这一篇博文主要是从源

逃离我推掉我的手/ 2022年09月29日 04:25/ 0 赞/ 231 阅读

相关 netty5笔记-线程模型2-EventLoopGroup

阅读本文之前，你需要对java的线程池有一定的了解，因为这里不会过多的讲解。今天我们主要的任务就是看下netty中一个非常重要的类EventLoop，通过这系列文章

绝地灬酷狼/ 2022年05月28日 01:38/ 0 赞/ 190 阅读

相关 netty5笔记-线程模型3-EventLoop

NioEventLoop相对NioEventLoopGroup来说就复杂很多了，需要一定的耐心来看这篇文章。首先从NioEventLoop的启动讲起，对于线

落日映苍穹つ/ 2022年05月28日 01:38/ 0 赞/ 224 阅读

相关 netty5笔记-线程模型1-Promise

一起来学习下netty的线程池实现。我们知道java本身实现了一套线程池，即我们常见的ExecutorService。那么netty为什么还要定义自己的线程模型，什么时候适合

谁践踏了优雅/ 2022年05月28日 01:38/ 0 赞/ 314 阅读

相关 netty5笔记-线程模型4-无锁队列MpscLinkedQueue

NioEventLoop里面使用了MpscLinkedQueue作为taskQueue，替换了父类中默认的LinkedBlockingQueue队列。taskQueue主要用于

Myth丶恋晨/ 2022年05月27日 12:38/ 0 赞/ 311 阅读

相关 Netty线程模型

1. 背景 1.1. Java线程模型的演进 1.1.1. 单线程时间回到十几年前，那时主流的CPU都还是单核（除了商用高性能的小机），CPU的核心

淩亂°似流年/ 2022年05月23日 02:12/ 0 赞/ 275 阅读

相关 Netty 线程模型

首先，Netty 使用 EventLoop 来处理连接上的读写事件，而一个连接上的所有请求都保证在一个 EventLoop 中被处理，

小灰灰/ 2020年05月02日 15:58/ 0 赞/ 935 阅读