Netty之EventLoop

EventLoop:英译事件循环器，感觉起来就是是不停的处理事件
EventLoopGroup：事件循环器组，感觉就是一大推的EventLoop处理事件。那么究竟是怎么回事呢？往下面看看

本篇文章先通过查看EventLoop和EventLoopGroup实现的部分细节，然后分析我们在使用代码的启动流程，当然主要了解NioEventLoop和NioEventLoopGroup

1.EventLoopGoup

​ 首先，我们先纵览一下EventLoopGroup 的类结构图，如下图所示：

image

从上面图中先分析下EventLoopGroup有哪些功能：

• 首先通过ScheduledExecutorService发现使用的jdk的api，包含了调度任务的定时或某种频率执行任务，
• EventExecutorGoup 除了添加了迭代功能,next()和shutdown的功能等就是继承ScheduledExecutorService相关功能了
• EventLoopGroup 主要的功能有next获取下一个NextLoop,和register注册服务，类似将某一个channel注册到具体的EventLoop中

   EventLoop next();
   ChannelFuture register(Channel channel);

然后我们接着分析实现细节

1.1 AbstractEventExecutorGroup

明显发现没有成员变量，只有部分接口实现。可以简单的发现全部都是通过next()调用调度任务的方法，意味着next()就表示线程和线程池。所以接下来就需要看看next的实现了

public abstract class AbstractEventExecutorGroup implements EventExecutorGroup {
    @Override
    public Future submit(Runnable task) {
        return next().submit(task);
    }

    @Override
    public  Future submit(Runnable task, T result) {
        return next().submit(task, result);
    }

    @Override
    public  Future submit(Callable task) {
        return next().submit(task);
    }

    @Override
    public ScheduledFuture schedule(Runnable command, long delay, TimeUnit unit) {
        return next().schedule(command, delay, unit);
    }
....

1.2 MultithreadEventExecutorGroup

继续看成员变量

public abstract class MultithreadEventExecutorGroup extends AbstractEventExecutorGroup {

    private final EventExecutor[] children;   //持有 多个事件执行器数组
    private final Set readonlyChildren;  //只读执行器列表
    private final AtomicInteger terminatedChildren = new AtomicInteger();  //结束的执行器个数
    private final Promise terminationFuture = new DefaultPromise(GlobalEventExecutor.INSTANCE);
    private final EventExecutorChooserFactory.EventExecutorChooser chooser;    //执行器选择器
}

核心API看下

    //构造器中数据初始化
    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());
        }
        //一个线程对应一个eventExecutor
        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
                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;
                        }
                    }
                }
            }
        }
        //初始化不同的选择器，这里实现会根据线程的奇偶数不同返回不同的选择器，以用来提供执行效率
        chooser = chooserFactory.newChooser(children);

        final FutureListener