Netty源码解读EventExecutorGroup

EventExecutorGroup

该接口继承了ScheduledExecutorService接口和Iterable接口，对原来的ExecutorService的关闭接口提供了增强，提供了优雅的关闭接口。从接口名称上可以看出它是对多个EventExecutor的集合，提供了对多个EventExecutor的迭代访问接口。 （起始就是一个EventExecutor的容器）

所谓的优雅的关闭看下面几个方法的介绍
boolean isShuttingDown()：只有当这个EventExecutorGroup容器中所有的EventExecutor，调用shutdownGracefully优雅关闭接口或者shut down后，才会返回true

Future

/* * Copyright 2012 The Netty Project * * The Netty Project licenses this file to you under the Apache License, * version 2.0 (the "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at: * *   http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations * under the License. */package io.netty.util.concurrent;import java.util.Iterator;import java.util.List;import java.util.Set;import java.util.concurrent.Callable;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.TimeUnit;/** * The {@link EventExecutorGroup} is responsible for providing the {@link EventExecutor}'s to use * via its {@link #next()} method. Besides this, it is also responsible for handling their * life-cycle and allows shutting them down in a global fashion. * */public interface EventExecutorGroup extends ScheduledExecutorService, Iterable<EventExecutor> {    /**     * Returns {@code true} if and only if all {@link EventExecutor}s managed by this {@link EventExecutorGroup}     * are being {@linkplain #shutdownGracefully() shut down gracefuclly} or was {@linkplain #isShutdown() shut down}.     */    boolean isShuttingDown();    /**     * Shortcut method for {@link #shutdownGracefully(long, long, TimeUnit)} with sensible default values.     *     * @return the {@link #terminationFuture()}     */    Future<?> shutdownGracefully();    /**     * Signals this executor that the caller wants the executor to be shut down.  Once this method is called,     * {@link #isShuttingDown()} starts to return {@code true}, and the executor prepares to shut itself down.     * Unlike {@link #shutdown()}, graceful shutdown ensures that no tasks are submitted for <i>'the quiet period'</i>     * (usually a couple seconds) before it shuts itself down.  If a task is submitted during the quiet period,     * it is guaranteed to be accepted and the quiet period will start over.     *     * @param quietPeriod the quiet period as described in the documentation     * @param timeout     the maximum amount of time to wait until the executor is {@linkplain #shutdown()}     *                    regardless if a task was submitted during the quiet period     * @param unit        the unit of {@code quietPeriod} and {@code timeout}     *     * @return the {@link #terminationFuture()}     */    Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit);    /**     * Returns the {@link Future} which is notified when all {@link EventExecutor}s managed by this     * {@link EventExecutorGroup} have been terminated.     */    Future<?> terminationFuture();    /**     * @deprecated {@link #shutdownGracefully(long, long, TimeUnit)} or {@link #shutdownGracefully()} instead.     */    @Override    @Deprecated    void shutdown();    /**     * @deprecated {@link #shutdownGracefully(long, long, TimeUnit)} or {@link #shutdownGracefully()} instead.     */    @Override    @Deprecated    List<Runnable> shutdownNow();    /**     * Returns one of the {@link EventExecutor}s managed by this {@link EventExecutorGroup}.     */    EventExecutor next();    /**     * @deprecated Use {@link #children()} instead.     */    @Override    @Deprecated    Iterator<EventExecutor> iterator();    /**     * Returns the unmodifiable set of {@link EventExecutor}s managed by this {@link EventExecutorGroup}.     */    <E extends EventExecutor> Set<E> children();    @Override    Future<?> submit(Runnable task);    @Override    <T> Future<T> submit(Runnable task, T result);    @Override    <T> Future<T> submit(Callable<T> task);    @Override    ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);    @Override    <V> ScheduledFuture<V> schedule(Callable<V> 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);}