Netty源码1--NioEventLoopGroup

针对Netty的Reactor线程模型，从理论上来看确实设计的比较巧妙，将接受连接请求和处理读写事件分开，避免了一直阻塞的问题。看完这些，一直比较好奇的是Netty在代码中是如何实现的，于是开始研究Netty的源码，今天就先研究下NioEventLoopGroup这个类的具体实现过程。

    public void start() throws InterruptedException {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);  #1
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
           
    }

第一步首先初始化NioEventLoopGroup这个类，我们首先看下这个初始化操作做了些什么事情，具体的初始化操作主要在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) {
            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              
            } finally {
        }
        chooser = chooserFactory.newChooser(children);
    }

在这个类中，首先判断nThreads这个变量的值，这个值表示的是线程的数量，如果在NioEventLoopGroup初始化时没有传入这个值，默认为cpu核数*2。

excutor参数默认为null，初始化时主要是初始化了ThreadPerTaskExecutor 这个类中的threadFactory参数，从名称上也能看到这是个创建线程的工厂类。

children是个数组，数组的初始化是通过newChild这个方法完成，NioEventLoopGroup实现了此方法，下面具体看下这个方法的具体实现过程。

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

从newChild这个方法的实现上就可以看到，这个方法返回了一个新创建的NioEventLoop对象，所以children这个数组中存储的是NioEventLoop对象。NioEventLoop对象的初始化过程不再往下跟了，有需要再跟下。

初始化children数组后，通过DefaultEventExecutorChooserFactory工厂创建了一个EventExecutorChooser对象，这个对象非常重要，主要作用就是为channel分配到哪个NioEventLoop上确定分配策略，下面看下具体实现。

public final class DefaultEventExecutorChooserFactory implements EventExecutorChooserFactory {
    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;
    }

从上面这个工厂类中可以看到，此工厂类是根据executors这个数组的长度是否是2的幂次方，选择具体的EventExecutorChooser实现类，这两个子类的具体实现如下：

   private static final class PowerOfTwoEventExecutorChooser implements EventExecutorChooser {

        @Override
        public EventExecutor next() {
            return executors[idx.getAndIncrement() & executors.length - 1];
        }
    }

    private static final class GenericEventExecutorChooser implements EventExecutorChooser {
        @Override
        public EventExecutor next() {
            return executors[Math.abs(idx.getAndIncrement() % executors.length)];
        }
    }

从上面的代码就可以清楚的看到，主要是通过next方法从数组中选择一个NioEventLoop对象，后面会详细讲解这个next方法怎么使用的。至此，NioEventLoopGroup这个类的源码重要的部分就分析完了，总结一下：

1. 一个NioEventLoopGroup中会管理多个NioEventLoop对象，相当于线程池，NioEventLoop相当于线程。
2. NioEventLoopGroup中会初始化EventExecutorChooser对象，确定这个NioEventLoopGroup中分配NioEventLoop对象的策略。