Netty 中 EventLoopGroup 的创建

　　本文是基于 Netty 4.1.6.Final 的源码来分析的。

　　在分析源码之前做一些准备工作：

　　先熟悉一下 IDEA 的几个快捷键，能极大的提高我们查看源码的效率：

1. Ctrl + Alt + B：用鼠标点击指定的方法，然后按下快捷键，IDEA 就会跳转到该方法的定义的地方，如果是重写的方法，则会列出该方法的所有实现；
2. Ctrl + Alt + ←/→：跳转至前/后一次鼠标点击的地方，方便我们来回查看源码；
3. Ctrl + F12：弹出当前类的所有方法，可以直接敲字母来过滤方法；
4. Shift + F7：Debug 的时候，当一行代码中链式的调用了多个方法，按下该快捷键会弹出改行所有的方法，然后选择要进入的方法，查看源码。

1. 创建过程

1. 创建 1 个 executor，后续用来创建并执行线程；
2. 创建指定数量的 EventLoop；
   1. 为当前 EventLoop 创建 1 个 selector；
3. 根据 EventLoop 的数量创建指定类型的 chooser，后续用来分配线程。

2. 代码

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

　　这两行代码创建的 EventLoopGroup 分别用来处理新连接的接入和已接入连接的事件处理。

3. 源码分析

　　 NioEventLoopGroup 的构造方法，最终调用的是 MultithreadEventExecutorGroup 的构造方法：

protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                        EventExecutorChooserFactory chooserFactory, Object... args) {
    //...
    //1. 创建 executor
    if (executor == null) {
        executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
    }
    // EventLoopGroup 中的 EventLoop 数组
    children = new EventExecutor[nThreads];

    for (int i = 0; i < nThreads; i ++) {
        boolean success = false;
        try {
            //2. 创建 EventLoop
            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 {
            //...
        }
    }
    //3. 创建 chooser
    chooser = chooserFactory.newChooser(children);
    //..
}

3.1 executor 的创建

　　创建 executor 的构造方法中传入了 1 个 DefaultThreadFactory：

public DefaultThreadFactory(String poolName, boolean daemon, int priority, ThreadGroup threadGroup) {
    //... poolName 的值是 EventLoopGroup 的类名，首字母小写
    prefix = poolName + '-' + poolId.incrementAndGet() + '-';
    this.daemon = daemon;
    this.priority = priority;
    this.threadGroup = threadGroup;
}

　　ThreadPerTaskExecutor  类：

public final class ThreadPerTaskExecutor implements Executor {
    private final ThreadFactory threadFactory;

    public ThreadPerTaskExecutor(ThreadFactory threadFactory) {
        if (threadFactory == null) {
            throw new NullPointerException("threadFactory");
        }
        this.threadFactory = threadFactory;
    }

    @Override
    public void execute(Runnable command) {
        //通过线程工厂创建并启动线程
        threadFactory.newThread(command).start();
    }
}

　　DefaultThreadFactory 的 newThread(Runnable command)方法：

@Override
public Thread newThread(Runnable r) {
    //调用了后面的方法，最终创建的是 Netty 封装的 FastThreadLocalThread
    Thread t = newThread(new DefaultRunnableDecorator(r), prefix + nextId.incrementAndGet());
    try {//线程相关的设置
        if (t.isDaemon()) {
            if (!daemon) {
                t.setDaemon(false);
            }
        } else {
            if (daemon) {
                t.setDaemon(true);
            }
        }

        if (t.getPriority() != priority) {
            t.setPriority(priority);
        }
    } catch (Exception ignored) {
        // Doesn't matter even if failed to set.
    }
    return t;
}
protected Thread newThread(Runnable r, String name) {
    return new FastThreadLocalThread(threadGroup, r, name);
}

　　注意：这里只是分析了 executor 的创建，以及它创建线程的方法，这一阶段并没有创建和运行新线程。

3.2 EventLoop 的创建

　　newChild()方法将 executor 传了进去，这里以 NioEventLoop 举例，所以最终调用了 NioEventLoop 的构造方法：

NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider,
             SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler) {
    //executor 最终传递给父类 SingleThreadEventExecutor
    super(parent, executor, false, DEFAULT_MAX_PENDING_TASKS, rejectedExecutionHandler);
    if (selectorProvider == null) {
        throw new NullPointerException("selectorProvider");
    }
    if (strategy == null) {
        throw new NullPointerException("selectStrategy");
    }
    provider = selectorProvider;
    //创建 selector
    selector = openSelector();
    selectStrategy = strategy;
}

　　在 NioEventLoop 几个父类的构造方法中，创建了任务队列，暂时不做分析。

3.3 chooser 的创建

　　chooser 也是通过工厂模式创建的，参数 children 是前面创建的 EventLoop 数组，chooserFactory 会根据数组的长度是否为 2 的幂来创建 chooser。

@SuppressWarnings("unchecked")
@Override
public EventExecutorChooser newChooser(EventExecutor[] executors) {
    if (isPowerOfTwo(executors.length)) {
        return new PowerOfTowEventExecutorChooser(executors);
    } else {
        return new GenericEventExecutorChooser(executors);
    }
}

private static boolean isPowerOfTwo(int val) {
    //判断数组长度是否为 2 的幂
    //有符号数的计算：以 Byte 为例
    // 3  ---> 0000 0011                              0000 0011
    // -3 ---> 1000 0000 - 0000 0011 = 0111 1101 ===> 1111 1101  &
    //                                                0000 0000 
    // 2  ---> 0000 0010                              0000 0010
    // -2 ---> 1000 0000 - 0000 0010 = 0111 1110 ===> 1111 1110  &
    //                                                0000 0010
    return (val & -val) == val;
}

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

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

    @Override
    public EventExecutor next() {
        //因为 length 是 2 的幂，减去 1，退一位，二进制就全是 1
        //比如 8 是 1000，减 1 是 0111，将 idx 自增后和前面的值相与
        //相当于是循环取值
        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
    public EventExecutor next() {
        //普通的就是直接取模的绝对值
        return executors[Math.abs(idx.getAndIncrement() % executors.length)];
    }
}

 　　至此，EventLoopGroup 就创建完成了，boosGroup 和 wrokerGroup 的创建是一样的。