執行緒模型是Netty的核心設計，設計地很巧妙，之前專案中有一塊處理併發的設計和Netty的Eventloop單執行緒設計類似，效果得到了實證。

 

Netty5的類層次結構和之前的版本變化很大，網上也有很多文章寫Netty的執行緒模型，Reactor模式，比如這篇http://blog.csdn.net/xiaolang85/article/details/37873059， 應該是引自《Netty權威指南》，寫得比較全面，但是有幾個關鍵的概念沒講清楚。

 

這篇文章只講Netty5執行緒模型最重要的幾個關鍵點

第一個概念是如何理解NioEventLoop和NioEventLoopGroup：NioEventLoop實際上就是工作執行緒，可以直接理解為一個執行緒。NioEventLoopGroup是一個執行緒池，執行緒池中的執行緒就是NioEventLoop。Netty設計這幾個類的時候，層次結構挺複雜，反而讓人迷惑。

 

還有一個讓人迷惑的地方是，建立ServerBootstrap時，要傳遞兩個NioEventLoopGroup執行緒池，一個叫bossGroup,一個叫workGroup。《Netty權威指南》裡只說了bossGroup是用來處理TCP連線請求的，workGroup是來處理IO事件的。

這麼說是沒錯，但是沒說清楚bossGroup具體如何處理TCP請求的。實際上bossGroup中有多個NioEventLoop執行緒，每個NioEventLoop繫結一個埠，也就是說，如果程式只需要監聽1個埠的話，bossGroup裡面只需要有一個NioEventLoop執行緒就行了。

在上一篇文章介紹伺服器端繫結的過程中，我們看到最後是NioServerSocketChannel封裝的Java的ServerSocketChannel執行了繫結，並且執行accept()方法來建立客戶端SocketChannel的連線。一個埠只需要一個NioServerSocketChannel即可。

 

 

[java]  view plain copy      

1.                 EventLoopGroup bossGroup = new NioEventLoopGroup();  
2.         EventLoopGroup workerGroup = new NioEventLoopGroup();  
3.         try {  
4.             ServerBootstrap b = new ServerBootstrap();  
5.             b.group(bossGroup, workerGroup)  
6.                     .channel(NioServerSocketChannel.class)  
7.                     .option(ChannelOption.SO_BACKLOG, 1024)  
8.                     .childHandler(new ChildChannelHandler());  
9.               
10.             ChannelFuture f = b.bind(port).sync();  
11.             f.channel().closeFuture().sync();  
12.         } finally {  
13.             bossGroup.shutdownGracefully();  
14.             workerGroup.shutdownGracefully();  
15.         }  
16.   
17.   
18.     protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {  
19.         if (nThreads <= 0) {  
20.             throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));  
21.         }  
22.   
23.         if (executor == null) {  
24.             executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());  
25.         }  
26.   
27.         children = new EventExecutor[nThreads];  
28.         for (int i = 0; i < nThreads; i ++) {  
29.             boolean success = false;  
30.             try {  
31.                 children[i] = newChild(executor, args);  
32.                 success = true;  
33.             } catch (Exception e) {  
34.                 // TODO: Think about if this is a good exception type  
35.                 throw new IllegalStateException("failed to create a child event loop", e);  
36.             } finally {  

 

 

第二個概念是每個NioEventLoop都綁定了一個Selector，所以在Netty5的執行緒模型中，是由多個Selecotr在監聽IO就緒事件。而Channel註冊到Selector。

舉個例子，比如有100萬個連線連到伺服器端。平時的寫法可能是1個Selector執行緒監聽所有的IO就緒事件，1個Selector面對100萬個連線(Channel)。

而如果使用了1000個NioEventLoop的執行緒池來說，1000個Selector面對100萬個連線，每個Selector只需要關注1000個連線(Channel)

 

[java]  view plain copy      

1. public final class NioEventLoop extends SingleThreadEventLoop {  
2.   
3.     
4.     /** 
5.      * The NIO {@link Selector}. 
6.      */  
7.     Selector selector;  
8.     private SelectedSelectionKeySet selectedKeys;  
9.   
10.     private final SelectorProvider provider;  

 

第三個概念是一個Channel繫結一個NioEventLoop，相當於一個連線繫結一個執行緒，這個連線所有的ChannelHandler都是在一個執行緒中執行的，避免的多執行緒干擾。更重要的是ChannelPipline連結串列必須嚴格按照順序執行的。單執行緒的設計能夠保證ChannelHandler的順序執行。

 

[java]  view plain copy      

1. public interface Channel extends AttributeMap, Comparable<Channel> {  
2.   
3.     /** 
4.      * Return the {@link EventLoop} this {@link Channel} was registered too. 
5.      */  
6.     EventLoop eventLoop();  

 

 

第四個概念是一個NioEventLoop的selector可以被多個Channel註冊，也就是說多個Channel共享一個EventLoop。EventLoop的Selecctor對這些Channel進行檢查。

這段程式碼展示了執行緒池如何給Channel分配EventLoop,是根據Channel個數取模

 

[java]  view plain copy      

1.  public EventExecutor next() {  
2.         return children[Math.abs(childIndex.getAndIncrement() % children.length)];  
3.     }  
4.   
5. private void processSelectedKeysOptimized(SelectionKey[] selectedKeys) {  
6.         for (int i = 0;; i ++) {  
7.             // 逐個處理註冊的Channel  
8.             final SelectionKey k = selectedKeys[i];  
9.             if (k == null) {  
10.                 break;  
11.             }  
12.   
13.             final Object a = k.attachment();  
14.   
15.             if (a instanceof AbstractNioChannel) {  
16.                 processSelectedKey(k, (AbstractNioChannel) a);  
17.             } else {  
18.                 @SuppressWarnings("unchecked")  
19.                 NioTask<SelectableChannel> task = (NioTask<SelectableChannel>) a;  
20.                 processSelectedKey(k, task);  
21.             }  
22.   
23.             if (needsToSelectAgain) {  
24.                 selectAgain();  
25.                 // Need to flip the optimized selectedKeys to get the right reference to the array  
26.                 // and reset the index to -1 which will then set to 0 on the for loop  
27.                 // to start over again.  
28.                 //  
29.                 // See https://github.com/netty/netty/issues/1523  
30.                 selectedKeys = this.selectedKeys.flip();  
31.                 i = -1;  
32.             }  
33.         }  
34.     }  

 

理解了這4個概念之後就對Netty5的執行緒模型有了清楚的認識：

在監聽一個埠的情況下，一個NioEventLoop通過一個NioServerSocketChannel監聽埠，處理TCP連線。後端多個工作執行緒NioEventLoop處理IO事件。每個Channel繫結一個NioEventLoop執行緒，1個NioEventLoop執行緒關聯一個selector來為多個註冊到它的Channel監聽IO就緒事件。NioEventLoop是單執行緒執行，保證Channel的pipline在單執行緒中執行，保證了ChannelHandler的執行順序。

下面這張圖來之http://blog.csdn.net/xiaolang85/article/details/37873059， 基本能說清楚。