Netty源码解析—— EventLoop（二）之 EventLoopGroup

Netty源码解析—— EventLoop（二）之 EventLoopGroup

1.类结构图

NioEventLoopGroup.png

2. EventExecutorGroup

EventExecutorGroup 实现 ScheduledExecutorService 、Iterable接口，这两个接口都是jdk原生接口，具体看EventExecutorGroup接口中的方法，代码如下：

   // ========== 自定义接口 ===================================
   
    //是否正在关闭
    boolean isShuttingDown();

    //优雅关闭线程池
    Future shutdownGracefully();
  
    Future shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit);

    //返回线程池终止时的异步结果
    Future terminationFuture();

    //选择一个 EventExecutor 对象
    EventExecutor next();


  // ========== 实现自 Iterable 接口 ==========
    @Override
    Iterator iterator();


// ========== 实现自 ExecutorService 接口 ==========

    @Override
    @Deprecated
    void shutdown();

   
    @Override
    @Deprecated
    List shutdownNow();


    @Override
    Future submit(Runnable task);

    @Override
     Future submit(Runnable task, T result);

    @Override
     Future submit(Callable task);

    // ========== 实现自 ScheduledExecutorService 接口 ==========


    @Override
    ScheduledFuture schedule(Runnable command, long delay, TimeUnit unit);

    @Override
     ScheduledFuture schedule(Callable callable, long delay, TimeUnit unit);

    @Override
    ScheduledFuture scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit);

    @Override
    ScheduledFuture scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit);

• 重点关注next()方法，该方法的功能是从线程池中选择一个线程
• 比较特殊的是，接口方法返回类型为 Future 不是 Java 原生的 java.util.concurrent.Future ，而是 Netty 自己实现的 Future 接口，如下代码：

public interface Future extends java.util.concurrent.Future 

public interface ScheduledFuture extends Future, java.util.concurrent.ScheduledFuture 

3. AbstractEventExecutorGroup

io.netty.util.concurrent.AbstractEventExecutorGroup ，实现 EventExecutorGroup 接口，EventExecutor ( 事件执行器 )的分组抽象类。

3.1 submit

#submit(...) 方法，提交一个普通任务到 EventExecutor 中, 提交的 EventExecutor ，通过 #next() 方法选择

   @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);
    }

3.2 schedule

#schedule(...) 方法，提交一个定时任务到 EventExecutor 中,提交的 EventExecutor ，通过 #next() 方法选择。代码如下：

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

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

    @Override
    public ScheduledFuture scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
        return next().scheduleAtFixedRate(command, initialDelay, period, unit);
    }

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

3.3 execute

#execute(...) 方法，在 EventExecutor 中执行一个普通任务,不需要返回结果，代码如下：

    @Override
    public void execute(Runnable command) {
        next().execute(command);
    }

3.4 invokeAll

#invokeAll(...) 方法，在 EventExecutor 中执行多个普通任务, 多个任务使用同一个 EventExecuto。代码如下：

    @Override
    public  List> invokeAll(Collection> tasks)
            throws InterruptedException {
        return next().invokeAll(tasks);
    }

    @Override
    public  List> invokeAll(
            Collection> tasks, long timeout, TimeUnit unit) throws InterruptedException {
        return next().invokeAll(tasks, timeout, unit);
    }

3.5 invokeAny

#invokeAll(...) 方法，在 EventExecutor 中执行多个普通任务，有一个执行完成即可，多个任务使用同一个 EventExecutor 。代码如下：

    @Override
    public  T invokeAny(Collection> tasks) throws InterruptedException, ExecutionException {
        return next().invokeAny(tasks);
    }

    @Override
    public  T invokeAny(Collection> tasks, long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException {
        return next().invokeAny(tasks, timeout, unit);
    }

3.6 shutdown

#shutdown(...) 方法，关闭 EventExecutorGroup 。代码如下：

    @Override
    public Future shutdownGracefully() {
        return shutdownGracefully(DEFAULT_SHUTDOWN_QUIET_PERIOD, DEFAULT_SHUTDOWN_TIMEOUT, TimeUnit.SECONDS);
    }

    
    @Override
    @Deprecated
    public abstract void shutdown();

  
    @Override
    @Deprecated
    public List shutdownNow() {
        shutdown();
        return Collections.emptyList();
    }

• 具体的 #shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit) 和 #shutdown() 方法，由子类实现。

4. MultithreadEventExecutorGroup

4.1 构造方法

/**
     * EventExecutor 数组
     */
    private final EventExecutor[] children;
    /**
     * 不可变( 只读 )的 EventExecutor 数组
     */
    private final Set readonlyChildren;
    /**
     * 已终止的 EventExecutor 数量
     */
    private final AtomicInteger terminatedChildren = new AtomicInteger();
    /**
     * 用于终止 EventExecutor 的异步 Future
     */
    private final Promise terminationFuture = new DefaultPromise(GlobalEventExecutor.INSTANCE);
    /**
     * EventExecutor 选择器
     */
    private final EventExecutorChooserFactory.EventExecutorChooser chooser;

   
    protected MultithreadEventExecutorGroup(int nThreads, ThreadFactory threadFactory, Object... args) {
        this(nThreads, threadFactory == null ? null : new ThreadPerTaskExecutor(threadFactory), args);
    }

   
    protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
        this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
    }

    
    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 {
                // 创建 EventExecutor 对象，newChild抽象方法，具体有子类实现
                children[i] = newChild(executor, args);
                // 标记创建成功
                success = true;
            } catch (Exception e) {
                // 创建失败，抛出 IllegalStateException 异常
                // TODO: Think about if this is a good exception type
                throw new IllegalStateException("failed to create a child event loop", e);
            } finally {
                // 创建失败，关闭所有已创建的 EventExecutor
                if (!success) {
                    // 优雅的关闭所有已创建的 EventExecutor，只负责关闭线程，并不知道关闭的结果
                    for (int j = 0; j < i; j ++) {
                        children[j].shutdownGracefully();
                    }
                    // 确保所有已创建的 EventExecutor 已关闭
                    for (int j = 0; j < i; j ++) {
                        EventExecutor e = children[j];
                        try {
                            //isTerminated() 若关闭后所有任务都已完成，则返回true。注意除非首先调用shutdown或shutdownNow，否则isTerminated永不为true。
                            // 返回：若关闭后所有任务都已完成，则返回true。
                            while (!e.isTerminated()) {
                                //等所有已提交的任务（包括正在跑的和队列中等待的）执行完
                                //或者等超时时间到
                                //或者线程被中断，抛出InterruptedException
                                e.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
                            }
                        } catch (InterruptedException interrupted) {
                            // Let the caller handle the interruption.
                            Thread.currentThread().interrupt();
                            break;
                        }
                    }
                }
            }
        }

        // 创建 EventExecutor 选择器
        chooser = chooserFactory.newChooser(children);

        // 创建监听器，用于 EventExecutor 终止时的监听
        //回调的具体逻辑是，当所有 EventExecutor 都终止完成时，
        // 通过调用 Future#setSuccess(V result) 方法，通知监听器们。至于为什么设置的值是 null ，因为监听器们不关注具体的结果。
        final FutureListener