Netty学习笔记通信调度篇：上层接口源码解析

 

我们按继承关系解析一下出现在这张图中的类

目录

EventExecutorGroup

Iterable

EventExecutor

AbstractEventExecutorGroup

AbstractEventExecutor

---

EventExecutorGroup

先看一下接口内部定义的方法

public interface EventExecutorGroup extends ScheduledExecutorService, Iterable<EventExecutor> {
    //是否正在关闭，只有调用shutdownGracefully兄弟方法或者其他方法，这个是根据实现走的所以再说实现的时候在细讲。
    boolean isShuttingDown();
    //优美关闭线程池，怎么优美了看他实现就是了。
    Future<?> shutdownGracefully();
    //上方的重载，具体实现按照代码讲解，这里总结为之过早。
    Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit);
    //返回终止时执行的Future操作结果。实现时细讲。
    Future<?> terminationFuture();
    //此方法来自于ScheduledExecutorService具体讲解查看上文
    @Override
    @Deprecated
    void shutdown();
    //此方法来自于ScheduledExecutorService具体讲解查看上文
    @Override
    @Deprecated
    List<Runnable> shutdownNow();
    //返回一个由EventExecutorGroup管理的EventExecutor
    EventExecutor next();

    //此方法重写与Iterable接口下方单独介绍
    @Override
    Iterator<EventExecutor> iterator();
    //此方法来自于ScheduledExecutorService具体讲解查看上文
    @Override
    Future<?> submit(Runnable task);
    //此方法来自于ScheduledExecutorService具体讲解查看上文
    @Override
    <T> Future<T> submit(Runnable task, T result);
    //此方法来自于ScheduledExecutorService具体讲解查看上文
    @Override
    <T> Future<T> submit(Callable<T> task);
    //此方法来自于ScheduledExecutorService具体讲解查看上文
    @Override
    ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);
    //此方法来自于ScheduledExecutorService具体讲解查看上文
    @Override
    <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit);
    //此方法来自于ScheduledExecutorService具体讲解查看上文
    @Override
    ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit);
    //此方法来自于ScheduledExecutorService具体讲解查看上文
    @Override
    ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit);
}

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

EventExecutorGroup继承了ScheduledExecutorService接口，而EventExecutorGroup自己定义了如下的新方法：

方法	说明
EventExecutor next()	取出一个EventExecutor, 这个方法要实现派发任务的策略。
Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit);	优雅地关闭这个executor, 一旦这个方法被调用，isShuttingDown()方法总是总是返回true。和 shutdown方法不同，这个方法需要确保在关闭的平静期(由quietPeriod参数决定)没有新的任务被提交，如果平静期有新任务提交，它会接受这个任务，同时中止关闭动作，等任务执行完毕后从新开始关闭流程。
Future<?> shutdownGracefully()	shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit)快捷调用方式。
boolean isShuttingDown()	检查是否已经调用了shutdownGracefully或shutdown方法。

Iterable

 

//此接口用来标记当前类可进行迭代并且支持for语句进行遍历
public interface Iterable<T> {
    //获取当前类的迭代器，迭代器不会进行深入讲解，因为这个涉及到数据的存储方式内存等。如果讲又是一大堆，这里读者只用知道Iterator是获取元素的，常用的两个方法hasNext()是否还有下一个数据和next()返回当前数据并且做好获取下一个的准备，这里光说可能不理解，举个例子数组[1,2]，调用next则从下标0获取并且下标+1,再次next则获取下标为1的那么自然返回2，再次next会发现没有了那么迭代器报错，所以就需要使用hasNext方法判断是否有下一个，而他的判断方法根据现实数据结构走，如果按上面的例子那么就是判断当前的下标是否小于数组的length。
    Iterator<T> iterator();
    //java8的特性接口的default方法和接受一个函数进行调用。
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
    //分割迭代器，支持java8的stream操作，这里暂不进行介绍。
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

EventExecutor

//EventExecutor是对执行器的定义，此定义是对EventExecutorGroup的一个扩展从而是一个特殊的group但是他并不是executor的group而是Thread的group。
public interface EventExecutor extends EventExecutorGroup {
    //在group中我们讲解了next它采用了executor的选择器来返回next，而此处的next是对group的重写代表的意义则是返回本身executor也就是this。
    @Override
    EventExecutor next();
    //在创建executor的时候会将group传入到executor中而此方法就是为了方便获取当前group所提供的，具体等讲实现的时候将会详细介绍
    EventExecutorGroup parent();
    //如果当前执行executor是当前线程则返回true否则是false
    //判断当前线程是否是执行线程
    boolean inEventLoop();
    //可以说上方方法是此方法的重载，因为此处可以指定一个线程判断执行线程是否是传入的线程
    //而上方方法则默认传入了当前线程
    boolean inEventLoop(Thread thread);
    //创建一个应答,应答的概念在前文已经详细说明过
    <V> Promise<V> newPromise();
    //创建一个进度应答，可以对程序的执行进度进行监听，在前文future中也详细介绍过此处不再做详细说明
    <V> ProgressivePromise<V> newProgressivePromise();

    //创建一个成功的future，创建完成的同时
    //所有阻塞等待结果的方法都会被唤醒
    //所有监听器都会接收到通知
    //isSuccess会返回true
    <V> Future<V> newSucceededFuture(V result);
    //创建一个失败future，创建完成的同时
    //所有阻塞等待结果的方法都会被唤醒
    //所有监听器都会接收到通知
    //isSuccess会返回false
    <V> Future<V> newFailedFuture(Throwable cause);
}

AbstractEventExecutorGroup

AbstractEventExecutorGroup是EventExecutorGroup的抽象实现类，因为他是抽象类所以只实现了几个方法,在讲解之前想讲述ExecutorGroup和Executor的关系，他们都是实现与EventExecutorGroup，但是他们并不一样实现与他是因为内部功能一样所以实现与这个接口，group用于对executor的管理比如关闭线程组的时候线程组会遍历管理的executor去挨个关闭。所以在阅读的api的时候不要因为他们的实现关系而乱了思维。

//这个抽象类并没有对executor组进行管理的操作所以此类也算是一个定义类。在讲解他的继承类的时候将会讲解此处的使用。所以暂时此类并没有任何意义。
public abstract class AbstractEventExecutorGroup implements EventExecutorGroup {
    
    @Override
    public Future<?> submit(Runnable task) {
        return next().submit(task);
    }

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

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

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

    @Override
    public <V> ScheduledFuture<V> schedule(Callable<V> 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);
    }

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

    /**
     * @deprecated {@link #shutdownGracefully(long, long, TimeUnit)} or {@link #shutdownGracefully()} instead.
     */
    @Override
    @Deprecated
    public abstract void shutdown();

    /**
     * @deprecated {@link #shutdownGracefully(long, long, TimeUnit)} or {@link #shutdownGracefully()} instead.
     */
    @Override
    @Deprecated
    public List<Runnable> shutdownNow() {
        shutdown();
        return Collections.emptyList();
    }

    @Override
    public <T> List<java.util.concurrent.Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
            throws InterruptedException {
        return next().invokeAll(tasks);
    }

    @Override
    public <T> List<java.util.concurrent.Future<T>> invokeAll(
            Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException {
        return next().invokeAll(tasks, timeout, unit);
    }

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

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

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

AbstractEventExecutor

//从申明可以看出他是继承与AbstractExecutorService而此类在ExecutorService的文章集中有详细的介绍
public abstract class AbstractEventExecutor extends AbstractExecutorService implements EventExecutor {
    private static final InternalLogger logger = InternalLoggerFactory.getInstance(AbstractEventExecutor.class);
    //默认的关闭前的时间具体描述将会结合使用时进行讲述
    static final long DEFAULT_SHUTDOWN_QUIET_PERIOD = 2;
    //默认的关闭超时时间
    static final long DEFAULT_SHUTDOWN_TIMEOUT = 15;
    //当前执行器所属的执行组
    private final EventExecutorGroup parent;
    //之前说过EventExecutor也是继承与Group所以他里面也有迭代的实现而为了切合他的迭代方法此处采用了只有一个元素的集合实现
    private final Collection<EventExecutor> selfCollection = Collections.<EventExecutor>singleton(this);

    protected AbstractEventExecutor() {
        this(null);
    }

    protected AbstractEventExecutor(EventExecutorGroup parent) {
        this.parent = parent;
    }

    @Override
    public EventExecutorGroup parent() {
        return parent;
    }

    @Override
    public EventExecutor next() {
        return this;
    }
    //之前说过inEvent的实现就是调用了重载的inEvent默认传入的是当前线程
    @Override
    public boolean inEventLoop() {
        return inEventLoop(Thread.currentThread());
    }
    //默认的迭代器
    @Override
    public Iterator<EventExecutor> iterator() {
        return selfCollection.iterator();
    }
    //刚才说的两个默认值使用地方就是此处设置默认的超时时间和超时前时间，这两个时间的使用会在具体实现出讲解
    @Override
    public Future<?> shutdownGracefully() {
        return shutdownGracefully(DEFAULT_SHUTDOWN_QUIET_PERIOD, DEFAULT_SHUTDOWN_TIMEOUT, TimeUnit.SECONDS);
    }
    //已经被废弃建议使用shutdownGracefully
    /**
     * @deprecated {@link #shutdownGracefully(long, long, TimeUnit)} or {@link #shutdownGracefully()} instead.
     */
    @Override
    @Deprecated
    public abstract void shutdown();

    /**
     * @deprecated {@link #shutdownGracefully(long, long, TimeUnit)} or {@link #shutdownGracefully()} instead.
     */
    @Override
    @Deprecated
    public List<Runnable> shutdownNow() {
        shutdown();
        return Collections.emptyList();
    }

    @Override
    public <V> Promise<V> newPromise() {
        return new DefaultPromise<V>(this);
    }

    @Override
    public <V> ProgressivePromise<V> newProgressivePromise() {
        return new DefaultProgressivePromise<V>(this);
    }

    @Override
    public <V> Future<V> newSucceededFuture(V result) {
        return new SucceededFuture<V>(this, result);
    }

    @Override
    public <V> Future<V> newFailedFuture(Throwable cause) {
        return new FailedFuture<V>(this, cause);
    }

    @Override
    public Future<?> submit(Runnable task) {
        return (Future<?>) super.submit(task);
    }

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

    @Override
    public <T> Future<T> submit(Callable<T> task) {
        return (Future<T>) super.submit(task);
    }

    @Override
    protected final <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new PromiseTask<T>(this, runnable, value);
    }

    @Override
    protected final <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new PromiseTask<T>(this, callable);
    }

    @Override
    public ScheduledFuture<?> schedule(Runnable command, long delay,
                                       TimeUnit unit) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
        throw new UnsupportedOperationException();
    }

    @Override
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
        throw new UnsupportedOperationException();
    }

    @Override
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
        throw new UnsupportedOperationException();
    }

    //安全运行任务说白了就是try了所有的异常
    //剩下的方法并没有什么可以讲的因为都基本是默认的实现就是创建内容什么的所以此处跳过，如果有疑问可以提问题一起讨论
    protected static void safeExecute(Runnable task) {
        try {
            task.run();
        } catch (Throwable t) {
            logger.warn("A task raised an exception. Task: {}", task, t);
        }
    }
}