netty服务端源码分析之eventloop和eventloopgroup

在众多的编程语言和网络库中，拿来介绍网络编程的例子，echo服务器和客户端恐怕是最多的一个例子。netty作为一个在java语言中应用非常广泛、非常优秀的网络编程框架，echo服务器和客户端程序往往是大家第一个接触的实例程序。很多工程师正是通过echo服务器和客户端跨入netty的大门。

我们先看一个echo服务器的完整实例代码：

/**
 * Echoes back any received data from a client.
 */
public final class EchoServer {

    static final boolean SSL = System.getProperty("ssl") != null;
    static final int PORT = Integer.parseInt(System.getProperty("port", "8007"));
    
    public static void main(String[] args) throws Exception {
        
        // Configure SSL.
        final SslContext sslCtx;
        if (SSL) {
            SelfSignedCertificate ssc = new SelfSignedCertificate();
            sslCtx = SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey()).build();
        } else {
            sslCtx = null;
        }
        
        // Configure the server.
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                // 把ServerBootstrap的channelfactory设置为ReflectiveChannelFactory
                // 当执行channelfactory的newChannel方法时,会创建NioServerSocketChannel实例
             .channel(NioServerSocketChannel.class)
             .option(ChannelOption.SO_BACKLOG, 100)
                // 处理server Socket事件
             .handler(new LoggingHandler(LogLevel.INFO))
                // 处理client socket事件
             .childHandler(new ChannelInitializer() {
                 @Override
                 public void initChannel(SocketChannel ch) throws Exception {
                     ChannelPipeline p = ch.pipeline();
                     if (sslCtx != null) {
                         p.addLast(sslCtx.newHandler(ch.alloc()));
                     }
                     //p.addLast(new LoggingHandler(LogLevel.INFO));
                     p.addLast(new EchoServerHandler());
                 }
             });

            // Start the server.
            ChannelFuture f = b.bind(PORT).sync();

            // Wait until the server socket is closed.
            f.channel().closeFuture().sync();
        } finally {
            // Shut down all event loops to terminate all threads.
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

代码中前面一段跟SSL相关的代码我们先跳过，从这两行代码开始：

EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();

这里创建了两个EventLoopGroup对象bossGroup和workerGroup，bossGroup主要用来处理server socket监听client socket的连接请求，server socket接收了新建连接后，会把connection socket放到workerGroup中进行处理，也就是说workerGroup主要用来处理connection socket的网络IO和相关的业务逻辑。netty支持很多种线程模型，这种bossGroup和workerGroup的组合是比较典型的。

netty作为一个异步的事件驱动（event drivern）的网络应用程序框架，采用非阻塞的多路复用的网络io模型。连接建立、连接关闭、socket可读、socket可写这些状态的改变称为一个个“事件（event）”，当然事件也可以是应用程序添加的一个任务。而处理这些event的线程就是一个无限循环（for or while loop），没有事件发生时，线程一直等待事件的产生。当有事件发生时，则处理所有的事件，处理完后则开始下一个循环，继续等待新的事件的发生。所以这种处理逻辑叫做eventloop，eventloop与线程是一一对应的，一个eventloop对应一个线程，一个线程也只有一个eventloop。而eventloopgroup主要包含了一组eventloop（线程池），当然还有许多线程任务分发等管理功能。

eventloopgroup/eventloop是netty的核心部件之一，可以说是netty三大核心部件之一，另外两个是channel和pipeline。eventloopgroup/eventloop定义了netty的线程模型，包括channel对socket的操作、pipeline的业务处理、用户提交的任务在内的所有任务的分发调度和执行都是在eventloopgroup/eventloop中进行。

这里为eventloopgroup接口实例化的是类NioEventLoopGroup，NioEventLoopGroup基于java nio进行网络操作。

我们跟踪一下NioEventLoopGroup的构造函数，

NioEventLoopGroup

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

然后进入他的父类：

MultithreadEventLoopGroup

    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, Object... args) {
        this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
    }
    
    protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                            EventExecutorChooserFactory chooserFactory, Object... args) {
        
    }

这里进入了一个有实质内容的构造函数，在分析这个函数之前，我们先根据构造函数的调用链梳理一下构造函数的入参的值。

nThreads = (nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads);
executor = null;
chooserFactory = DefaultEventExecutorChooserFactory.INSTANCE;

args = [SelectorProvider SelectorProvider.provider(),
        SelectStrategyFactory DefaultSelectStrategyFactory.INSTANCE,
        RejectedExecutionHandler RejectedExecutionHandlers.reject()]

可见如果NioEventLoopGroup的构造函数如果nThreads为非0值，则为传入的实际值，如果为0或没有参数，则为DEFAULT_EVENT_LOOP_THREADS，我们看下DEFAULT_EVENT_LOOP_THREADS的定义，

DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
                "io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2));

继续跟下去，可以知道NettyRuntime.availableProcessors()默认值为Runtime.getRuntime().availableProcessors()，也就是说nThreads值默认为CPU核心数的2倍

接下来我们分析构造函数:

protected MultithreadEventExecutorGroup(int nThreads, Executor executor, EventExecutorChooserFactory chooserFactory, Object... args)

首先为executor重新赋值:

    if (executor == null) {
        // DefaultThreadFactory设置: 非daemon、线程优先级5、线程名字、线程组为当前线程所属组
        executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
    }

因为executor入参值为null，所以executor重新赋值为ThreadPerTaskExecutor类的一个新建实例，ThreadPerTaskExecutor就是eventloop的执行器，eventloop的所有任务都是通过调用ThreadPerTaskExecutor的execute()函数，从而创建一个线程，进而执行提交的任务的。ThreadPerTaskExecutor只有一个成员，线程工厂DefaultThreadFactory,这个线程工厂创建的线程实例设置的线程属性为：非daemon、线程优先级5、线程名的前缀、所属的线程组与当前线程相同，一句话，创建的是一个普通线程，其中线程名的前缀为：
nioEventLoopGroup-poolId-, poolId初始值为0，每创建一个DefaultThreadFactory实例值加1。

然后初始化EventLoopGroup的线程池，具体代码如下：

        // 创建一个数组，数组大小为线程的个数
        children = new EventExecutor[nThreads];

        for (int i = 0; i < nThreads; i ++) {
            boolean success = false;
            try {
                // 初始化线程executor
                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 {
                // 如果初始化一个线程executor时抛出异常，则执行这一段代码：关闭前面创建的所有executor，并等待所有线程退出运行
                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;
                        }
                    }
                }
            }
        }

初始化过程，在代码注释中已经说明了，关键语句children[i] = newChild(executor, args);我们先放下，待会再详细分析。

线程选择器初始化：

chooser = chooserFactory.newChooser(children);

chooser实现了eventloopgroup的任务分派，当需要向线程池提交一个新的任务时，如注册一个新的服务端socket到eventloop，则通过chooser选择一个具体的executor。从前面分析得知，chooserFactory是DefaultEventExecutorChooserFactory的一个实例，它的executor选择逻辑代码如下：

    public EventExecutorChooser newChooser(EventExecutor[] executors) {
        if (isPowerOfTwo(executors.length)) {
            return new PowerOfTwoEventExecutorChooser(executors);
        } else {
            return new GenericEventExecutorChooser(executors);
        }
    }

    private static boolean isPowerOfTwo(int val) {
        return (val & -val) == val;
    }

    private static final class PowerOfTwoEventExecutorChooser implements EventExecutorChooser {
        private final AtomicInteger idx = new AtomicInteger();
        private final EventExecutor[] executors;

        PowerOfTwoEventExecutorChooser(EventExecutor[] executors) {
            this.executors = executors;
        }

        @Override
        // executor数是2的n次方，用与来计算，改善性能
        public EventExecutor next() {
            return executors[idx.getAndIncrement() & executors.length - 1];
        }
    }

    private static final class GenericEventExecutorChooser implements EventExecutorChooser {
        private final AtomicInteger idx = new AtomicInteger();
        private final EventExecutor[] executors;

        GenericEventExecutorChooser(EventExecutor[] executors) {
            this.executors = executors;
        }

        @Override
        // executor数不是2的n次方，用除法求余的方式计算
        public EventExecutor next() {
            return executors[Math.abs(idx.getAndIncrement() % executors.length)];
        }
    }

可见，线程池中的个数是2的n次方与不是2的n次方，具体的计算方法不一样，但效果都是round-robin的选择方法。

最后，为线程池的每一个EventExcutor注册一个结束后的回调函数，并把所有的EventExcutor保存到一个不可修改的Set中。具体代码如下：

        // 线程结束时的回调函数
        final FutureListener