netty的线程池-----揭示了使用两个线程池的原因

线程模型是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即可。

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. ChannelFuture f = b.bind(port).sync();
10. f.channel().closeFuture().sync();
11. } finally {
12. bossGroup.shutdownGracefully();
13. workerGroup.shutdownGracefully();
14. }
15. protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
16. if (nThreads <= 0) {
17. throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
18. }
19. if (executor == null) {
20. executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
21. }
22. children = new EventExecutor[nThreads];
23. for (int i = 0; i < nThreads; i ++) {
24. boolean success = false;
25. try {
26. children[i] = newChild(executor, args);
27. success = true;
28. } catch (Exception e) {
29. // TODO: Think about if this is a good exception type
30. throw new IllegalStateException("failed to create a child event loop", e);
31. } finally {

第二个概念是每个NioEventLoop都绑定了一个Selector，所以在Netty5的线程模型中，是由多个Selecotr在监听IO就绪事件。而Channel注册到Selector。

举个例子，比如有100万个连接连到服务器端。平时的写法可能是1个Selector线程监听所有的IO就绪事件，1个Selector面对100万个连接(Channel)。

而如果使用了1000个NioEventLoop的线程池来说，1000个Selector面对100万个连接，每个Selector只需要关注1000个连接(Channel)

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

第三个概念是一个Channel绑定一个NioEventLoop，相当于一个连接绑定一个线程，这个连接所有的ChannelHandler都是在一个线程中执行的，避免的多线程干扰。更重要的是ChannelPipline链表必须严格按照顺序执行的。单线程的设计能够保证ChannelHandler的顺序执行。

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

第四个概念是一个NioEventLoop的selector可以被多个Channel注册，也就是说多个Channel共享一个EventLoop。EventLoop的Selecctor对这些Channel进行检查。

这段代码展示了线程池如何给Channel分配EventLoop,是根据Channel个数取模

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

理解了这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， 基本能说清楚。