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

netty核心类源码解析：分析netty的运行机制

1. EventLoopGroup与EventLoop解析：分析netty的线程模型

这一篇博文主要是从源码层次分析netty的线程模型。netty之所以是高性能NIO框架，其中主要贡献之一就是netty的线程模型的高性能，我们都知道netty的线程模型是基于Reactor线程模型，下面我们就来分析一下对于netty的reactor线程模型是如何实现的。

1. NioEventLoopGroup

netty的程序的启动(在服务端一般是两个NioEventLoopGroup线程池，一个boss, 一个worker； 对于客户端一般是一个线程池)。我们一般是使用NIO，所以本文也全部是基于NIO来分析的，当然netty也支持BIO，不过本文就不做分析了。对于这个类的分析，我们首先从Reactor线程模型开始分析

1.1 Reactor线程模型

Reactor线程模型有三种

• 单线程模型
• 多线程模型
• 主从Reactor线程模型

关于这三种线程模型的原型，可以参考我之前的一片博文，我这里就不重复列出了，传送门：

Reactor线程模型以及在netty中的应用
http://blog.csdn.net/u010853261/article/details/55805216

1.2 NioEventLoopGroup与Reactor线程模型的对应

前面介绍了Reactor线程模型的原型实现，那么NIOEventLoopGroup是怎么与Reactor关联在一起的呢？ 其实NIOEventLoopGroup就是一个线程池实现，通过设置不同的NIOEventLoopGroup方式就可以对应三种不同的Reactor线程模型。

这里我只给出服务端的配置，对于客户端都是一样的。

单线程模型

下面直接给出配置的实例：

EventLoopGroup bossGroup = new NioEventLoopGroup(1);
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup)
 .channel(NioServerSocketChannel.class);
//.....

上面实例化了一个NIOEventLoopGroup，构造参数是1表示是单线程的线程池。然后接着我们调用 b.group(bossGroup) 设置了服务器端的 EventLoopGroup. 有些朋友可能会有疑惑: 我记得在启动服务器端的 Netty 程序时, 是需要设置 bossGroup 和 workerGroup 的, 为什么这里就只有一个 bossGroup?
其实很简单, ServerBootstrap 重写了 group 方法:

@Override
public ServerBootstrap group(EventLoopGroup group) {
    return group(group, group);
}

因此当传入一个 group 时, 那么 bossGroup 和 workerGroup 就是同一个 NioEventLoopGroup 了.

这时候呢, 因为 bossGroup 和 workerGroup 就是同一个 NioEventLoopGroup, 并且这个 NioEventLoopGroup 只有一个线程, 这样就会导致 Netty 中的 acceptor 和后续的所有客户端连接的 IO 操作都是在一个线程中处理的. 那么对应到 Reactor 的线程模型中, 我们这样设置 NioEventLoopGroup 时, 就相当于 Reactor 单线程模型.

多线程模型

同理，先给出源码：

EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
 .channel(NioServerSocketChannel.class);
//...

bossGroup 中只有一个线程, 在workerGroup线程池中我没有指定线程数量，所以默认是 CPU 核心数乘以2, 因此对应的到 Reactor 线程模型中, 我们知道, 这样设置的 NioEventLoopGroup 其实就是 Reactor 多线程模型.

主从Reactor线程模型

实现方式如下：

EventLoopGroup bossGroup = new NioEventLoopGroup(4);
EventLoopGroup workerGroup = new NioEventLoopGroup();
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
 .channel(NioServerSocketChannel.class);
//...

Netty 的服务器端的 acceptor 阶段, 没有使用到多线程, 因此上面的 主从多线程模型 在 Netty 的服务器端是不存在的.

服务器端的 ServerSocketChannel 只绑定到了 bossGroup 中的一个线程, 因此在调用 Java NIO 的 Selector.select 处理客户端的连接请求时, 实际上是在一个线程中的, 所以对只有一个服务的应用来说, bossGroup 设置多个线程是没有什么作用的, 反而还会造成资源浪费。

经 Google, Netty 中的 bossGroup 为什么使用线程池的原因大家众所纷纭, 不过我在 stackoverflow 上找到一个比较靠谱的答案:

the creator of Netty says multiple boss threads are useful if we share NioEventLoopGroup between different server bootstraps, but I don’t see the reason for it.

意思就是说：netty作者说：我们在不同的服务器引导之间共享NioEventLoopGroup，多个boss线程是有用的，但我没有看到它的原因。

1.3 NioEventLoopGroup的实例化过程

下面来分析对NioEventLoopGroup类进行实例化的过程中发生了什么。

NioEventLoopGroup 类层次结构

先给出类图：

对于NioEventLoopGroup核心的类继承关系就是：

NioEventLoopGroup –》MultithreadEventLoopGroup –》MultithreadEventExecutorGroup

下面从这三个类出发分析NioEventLoopGroup实例化过程。

NioEventLoopGroup实例化过程

这里首先盗用一下网上的一张示意图(画图实在是太耗时间了，毕竟我懒)：

下面大致解释一下这个实例化过程做了什么：

（1）在NioEventLoopGroup构造器调用：
如果对于不指定线程数参数的构造器，默认设置为0(但是在后面的构造器中会判断，如果设置为0，就会初始化为2*CPU数量)；

public NioEventLoopGroup() {
    this(0);
}

然后调用：

public NioEventLoopGroup(int nThreads) {
    this(nThreads, (Executor) null);
}

这里设置了NioEventLoopGroup线程池中每个线程执行器默认是null(这里设置为null, 在后面的构造器中会判断，如果为null就实例化一个线程执行器)。

再调用：

 public NioEventLoopGroup(int nThreads, Executor executor) {
    this(nThreads, executor, SelectorProvider.provider());
}

这里就存在于JDK的NIO的交互了，这里设置了线程池的SelectorProvider， 通过SelectorProvider.provider() 返回。

然后调用：

public NioEventLoopGroup(
            int nThreads, Executor executor, final SelectorProvider selectorProvider) {
    this(nThreads, executor, selectorProvider, DefaultSelectStrategyFactory.INSTANCE);
}

在这个重载的构造器中又传入了默认的选择策略工厂DefaultSelectStrategyFactory；

最后调用：

public NioEventLoopGroup(int nThreads, Executor executor, final SelectorProvider selectorProvider,
                             final SelectStrategyFactory selectStrategyFactory) {
    super(nThreads, executor, selectorProvider, selectStrategyFactory, RejectedExecutionHandlers.reject());
}

这里就是调用父类MultithreadEventLoopGroup的构造器了， 这里还添加了线程的拒绝执行策略。

（2）在MultithreadEventLoopGroup构造器调用：

protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
    super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
}

构造器被定义成protect，表示只能在NioEventLoopGroup中被调用，一定层度上的保护作用。这里就是对线程数进行了判断，当nThreads为0 的时候就设置成 DEFAULT_EVENT_LOOP_THREADS 这个常量。这个常量的定义如下：其实就是在MultithreadEventLoopGroup的静态代码段，其实就是将DEFAULT_EVENT_LOOP_THREADS赋值为CPU核心数*2；

static {
    DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
            "io.netty.eventLoopThreads", Runtime.getRuntime().availableProcessors() * 2));

    if (logger.isDebugEnabled()) {
        logger.debug("-Dio.netty.eventLoopThreads: {}", DEFAULT_EVENT_LOOP_THREADS);
    }
}

接下来就是调用的基类MultithreadEventExecutorGroup的构造器：

（3）MultithreadEventExecutorGroup的构造器：

protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
    this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
}

这个构造器里面多传入了一个参数 DefaultEventExecutorChooserFactory.INSTANCE ， 通过这个EventLoop选择器工厂可以实例化GenericEventExecutorChooser这个类， 这个类是EventLoopGroup线程池里面的EventLoop的选择器，调用GenericEventExecutorChooser.next() 方法可以从线程池中选择出一个合适的EventLoop线程。

然后就是重载调用MultithreadEventExecutorGroup类的构造器：

构造器调用到了这里其实也就是不断向上传递调用的终点了，由于构造器代码比较长，我就删除一些校验和不重要的代码，只保留核心代码：

/**
 * 最终的创建实例构造器
 *
 * @param nThreads          该实例将使用的线程数
 * @param executor          将要使用的executor, 默认为null
 * @param chooserFactory    将要使用的EventExecutorChooserFactory
 * @param args              arguments which will passed to each {@link #newChild(Executor, Object...)} call
 */
protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                        EventExecutorChooserFactory chooserFactory, Object... args) {
    /** 1.初始化线程池 */
    //参数校验nThread合法性，
    if (nThreads <= 0) {
        throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
    }
    //executor校验非空, 如果为空就创建ThreadPerTaskExecutor, 该类实现了 Executor接口
    // 这个executor 是用来执行线程池中的所有的线程，也就是所有的NioEventLoop，其实从
    //NioEventLoop构造器中也可以知道，NioEventLoop构造器中都传入了executor这个参数。
    if (executor == null) {
        executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
    }

    //这里的children数组， 其实就是线程池的核心实现，线程池中就是通过指定的线程数组来实现线程池；
    //数组中每个元素其实就是一个EventLoop，EventLoop是EventExecutor的子接口。
    children = new EventExecutor[nThreads];

    //for循环实例化children数组，NioEventLoop对象
    for (int i = 0; i < nThreads; i ++) {
        boolean success = false;
        try {
            //newChild(executor, args) 函数在NioEventLoopGroup类中实现了, 
            // 实质就是就是存入了一个 NIOEventLoop类实例
            children[i] = newChild(executor, args);
            success = true;
        } catch (Exception e) {
            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) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            }
        }
    }//end foreach

    /** 2.实例化线程工厂执行器选择器: 根据children获取选择器 */
    chooser = chooserFactory.newChooser(children);

    /** 3.为每个EventLoop线程添加 线程终止监听器*/
    final FutureListener