Netty源码愫读（五）NioEventLoop与NioEventLoopGroup相关源码学习

1、nettey的线程模型

1.1、Rector模式

Reactor模式首先是事件驱动的，有一个或多个并发输入源，有一个Service Handler，有多个Request Handlers；这个Service Handler会同步的将输入的请求（Event）多路复用的分发给相应的Request Handler。

单线程模型：

单线程模型下，所有的IO操作都由同一个Reactor线程来完成，其主要职责如下：

• 作为服务端，接收客户端的TCP连接；
• 作为客户端，向服务端发起TCP连接；
• 读取通信对端的请求或者应答消息；
• 向通信对端发送消息请求或者应答消息。

Reactor单线程模型原理图如下：

reactor单线程模型.png

如图所示，由于Reactor模式使用的是异步非阻塞IO，所有的IO操作都不会导致阻塞。通常Reactor线程中聚合了多路复用器负责监听网络事件，当有新连接到来时，触发连接事件，Disdatcher负责使用Acceptor接受客户端连接，建立通信链路；当I/O事件就绪后，Disdatcher负责将事件分发到对应的event handler上负责处理。

该模型的缺点很明显，不适用于高负载、高并发的应用场景；由于只有一个Reactor线程，一旦挂彩，整个系统通信模块将不可用。

多线程模型：

该模型的特点：

• 专门由一个Reactor线程-Acceptor线程用于监听服务端，接收客户端连接请求；
• 网络I/O操作读、写等由Reactor线程池负责处理；
• 一个Reactor线程可同时处理多条链路，但一条链路只能对应一个Reactor线程，这样可避免并发操作问题。

reactor多线程模型.png

绝大多数场景下，Reactor多线程模型都可以满足性能需求，但是，在极个别特殊场景中，一个Reactor线程负责监听和处理所有的客户端连接可能会存在性能问题。例如并发百万客户端连接，或者服务端需要对客户端握手进行安全认证，但是认证本身非常损耗性能。因此，诞生了第三种线程模型。

主从多线程模型：

主从多线程模型.png

该模型的特点：

• 服务端使用一个独立的主Reactor线程池来处理客户端连接，当服务端收到连接请求时，从主线程池中随机选择一个Reactor线程作为Acceptor线程处理连接；
• 链路建立成功后，将新创建的SocketChannel注册到sub reactor线程池的某个Reactor线程上，由它处理后续的I/O操作。

具体介绍请参照：https://www.jianshu.com/p/b4de9b85c79d

1.2、netty中的Reactor模式

Netty同时支持Reactor单线程模型 、Reactor多线程模型和Reactor主从多线程模型，用户可根据启动参数配置在这三种模型之间切换。Netty线程模型原理图如下：

netty中的reactor模型.png

2、NioEventLoopGroup相关源码学习

NioEventLoopGroup类继承图：

NioEventLoopGroup类继承图.png

2.1、NioEventLoopGroup功能介绍

NioEventLoopGroup主要包含两方面的功能：

• 注册Channel，主要是将Channel与某个线程池绑定等；
• 线程池管理及任务管理等；

2.1.1、注册Channel

NioEventLoopGroup主要通过EventLoopGroup的register()方法进行Channel注册，具体实现是通过EventLoop的register()将Channel注册到对应EventLoop的Selector上，由Selector来调度Channel的相关事件，如读、写、Accept等事件。

而EventLoopGroup的设计是，它包含多个EventLoop（每一个EventLoop通常内部包含一个线程），在执行上述注册过程中是需要选择其中的一个EventLoop来执行上述注册行为，这里就出现了一个选择策略的问题，该选择策略接口是EventExecutorChooser，你也可以自定义一个实现。

2.1.2、线程池管理及任务执行

EventLoopGroup继承了EventExecutorGroup，EventExecutorGroup也是EventExecutor的集合，EventExecutorGroup也是掌管着EventExecutor的初始化工作，EventExecutorGroup对于Runnable任务的执行也是选择内部中的一个EventExecutor来做具体的执行工作。

netty中很多任务都是异步执行的，一旦当前线程要对某个EventLoop执行相关操作，如注册Channel到某个EventLoop，如果当前线程和所要操作的EventLoop内部的线程不是同一个，则当前线程就仅仅向EventLoop提交一个注册任务，对外返回一个ChannelFuture。

2.2、NioEventLoopGroup源码学习

NioEventLoopGroup中主要有以下实现：

2.2.1、线程组创建及初始化

主要是调用父类MultithreadEventLoopGroup的构造方法进行初始，而MultithreadEventLoopGroup又调用MultithreadEventExecutorGroup对线程组进行初始化，其中包括EventExecutor数组初始化、EventExecutorChooser初始化及相关线程监听器初始化等；

2.2.2、IoRatio初始化

源码如下：

public void setIoRatio(int ioRatio) {
    for (EventExecutor e: this) {
        ((NioEventLoop) e).setIoRatio(ioRatio);
    }
}

其主要是调用NioEventLoop的方法对执行时间占比进行设置；

2.2.3、重建selector

源码如下：

public void rebuildSelectors() {
    for (EventExecutor e: this) {
        ((NioEventLoop) e).rebuildSelector();
    }
}

主要是调用NioEventLoop的方法进行重建；

2.2.3、创建子执行器

源码如下：

protected EventLoop newChild(Executor executor, Object... args) throws Exception {
    return new NioEventLoop(this, executor, (SelectorProvider) args[0],
        ((SelectStrategyFactory) args[1]).newSelectStrategy(), (RejectedExecutionHandler) args[2]);
}

NioEventLoopGroup创建NioEventLoop类型的子执行器；

2.3、MultithreadEventExecutorGroup源码学习

2.3.1、基本属性

private final EventExecutor[] children;
private final Set readonlyChildren;
private final AtomicInteger terminatedChildren = new AtomicInteger();
private final Promise terminationFuture = new DefaultPromise(GlobalEventExecutor.INSTANCE);
private final EventExecutorChooserFactory.EventExecutorChooser chooser;

children：EventExecutor类型的子执行器数组
readonlyChildren：只读执行器
terminatedChildren：已终止的执行器个数；
terminationFuture：线程终止异步结果
chooser：子执行器选择器；

2.3.2、构造函数

实现源码：

protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                        EventExecutorChooserFactory chooserFactory, Object... args) {
    if (nThreads <= 0) {
        throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
    }

    if (executor == null) {
        executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
    }

    children = new EventExecutor[nThreads];

    for (int i = 0; i < nThreads; i ++) {
        boolean success = false;
        try {
            children[i] = newChild(executor, args);
            success = true;
        } catch (Exception e) {
            // TODO: Think about if this is a good exception type
            throw new IllegalStateException("failed to create a child event loop", e);
        } finally {
            if (!success) {
                for (int j = 0; j < i; j ++) {
                    children[j].shutdownGracefully();
                }

                for (int j = 0; j < i; j ++) {
                    EventExecutor e = children[j];
                    try {
                        while (!e.isTerminated()) {
                            e.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
                        }
                    } catch (InterruptedException interrupted) {
                        // Let the caller handle the interruption.
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            }
        }
    }

    chooser = chooserFactory.newChooser(children);

    final FutureListener