netty系列之（三）——EventLoop和EventLoopGroup

一、线程模型

Netty的线程模型

Q

1、默认情况下netty服务端起多少个线程？何时启动？
2、netty如何解决jdk空轮询的bug？
3、netty如何保证异步串行无锁化？

过程

1、NioEventLoop创建
2、NioEventLoop启动
3、NioEventLoop执行逻辑

private EventLoopGroup bossGroup = new NioEventLoopGroup(1);
private EventLoopGroup workerGroup = new NioEventLoopGroup();//用于处理I/O相关的读写操作，或者执行Task

服务端启动的时候，创建了两个NioEventLoopGroup，它们实际是两个独立的Reactor线程池。一个用于接收客户端的TCP连接，另一个用于处理I/O相关的读写操作，或者执行系统Task、定时任务Task等。
Netty用于接收客户端请求的线程池职责如下。

• 接收客户端TCP连接，初始化Channel参数；
• 将链路状态变更事件通知给ChannelPipeline。

Netty处理I/O操作的Reactor线程池职责如下。

• 异步读取通信对端的数据报，发送读事件到ChannelPipeline；
• 异步发送消息到通信对端，调用ChannelPipeline的消息发送接口；
• 执行系统调用Task；
• 执行定时任务Task，例如链路空闲状态监测定时任务。

为了尽可能地提升性能，Netty在很多地方进行了无锁化的设计，例如在I/O线程内部进行串行操作，避免多线程竞争导致的性能下降问题。表面上看，串行化设计似乎CPU利用率不高，并发程度不够。但是，通过调整NIO线程池的线程参数，可以同时启动多个串行化的线程并行运行，这种局部无锁化的串行线程设计相比一个队列—多个工作线程的模型性能更优。
Netty的NioEventLoop读取到消息之后，直接调用ChannelPipeline的fireChannelRead (Object msg)。只要用户不主动切换线程，一直都是由NioEventLoop调用用户的Handler，期间不进行线程切换。这种串行化处理方式避免了多线程操作导致的锁的竞争，从性能角度看是最优的。
netty线程使用建议：

（1）创建两个NioEventLoopGroup，用于逻辑隔离NIO acceptor和NIO I/O线程。
（2）尽量不要在ChannelHandler中启动用户线程（解码后用于将POJO消息派发到后端业务线程的除外）。
（3）解码要放在NIO线程调用的解码Handler中进行，不要切换到用户线程中完成消息的解码。
（4）如果业务逻辑操作非常简单，没有复杂的业务逻辑计算，没有可能会导致线程被阻塞的磁盘操作、数据库操作、网路操作等，可以直接在NIO线程上完成业务逻辑编排，不需要切换
（5）如果业务逻辑处理复杂，不要在NIO线程上完成，建议将解码后的POJO消息封装成Task，派发到业务线程池中由业务线程执行，以保证NIO线程尽快被释放，处理其他的I/O操作。推荐的线程数量计算公式有以下两种。
•公式一：线程数量=（线程总时间/瓶颈资源时间）×瓶颈资源的线程并行数。
•公式二：QPS=1000/线程总时间×线程数。

二、NioEventLoop源码解析

NioEventLoop类图.png

图片.png

1、NioEventLoop创建

NioEventLoop创建步骤：

• new ThreadPerTaskExecutor()[线程创建器]:线程执行器的作用是负责创建NioEventLoopGroup对应底层线程
• for(){newChild()}[构造NioEventLoop]:创建NioEventLoop对象数组,for循环创建每个NioEventLoop,调用newChild()配置NioEventLoop核心参数
• chooserFactory.newChooser()[线程选择器]:给每个新连接分配NioEventLoop线程
  
  chooserFactory.newChooser
  
  
  PowerOfTwoEventExecutorChooser.next
  
  (1)、NioEventLoopGroup与ThreadPerTaskExecutor线程创建器

public NioEventLoopGroup() {
        this(0);
}

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

//线程组默认线程数为2倍的cpu数
//DEFAULT_EVENT_LOOP_THREADS=2*Runtime.getRuntime().availableProcessors()
protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
    super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
}

#MultithreadEventExecutorGroup类，核心方法
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) {
            //线程创建器，负责创建NioEventLoopGroup对应底层线程
            executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
        }

        children = new EventExecutor[nThreads];//创建NioEventLoop对象数组

        for (int i = 0; i < nThreads; i ++) {
            boolean success = false;
            try {
                //for循环创建每个NioEventLoop,调用newChild()，配置NioEventLoop核心参数
                children[i] = newChild(executor, args);//newChild
                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;
                        }
                    }
                }
            }
        }
        //线程选择器,给每个新连接分配NioEventLoop线程
        chooser = chooserFactory.newChooser(children);

        final FutureListener