Netty源码解析 —— concurrency

线程模型

概述

因为具有多核心或多个CPU 的计算机现在已经司空见惯，大多数的现代应用程序都利用了
复杂的多线程处理技术以有效地利用系统资源。相比之下，在早期的Java 语言中，我们使用多
线程处理的主要方式无非是按需创建和启动新的Thread来执行并发的任务单元——一种在高
负载下工作得很差的原始方式。Java 5 随后引入了Executor API，其线程池通过缓存和重用
Thread 极大地提高了性能。

基本的线程池化模式可以描述为：

• 从池的空闲线程列表中选择一个Thread，并且指派它去运行一个已提交的任务（一个
  Runnable 的实现）；
• 当任务完成时，将该Thread 返回给该列表，使其可被重用。

虽然池化和重用线程相对于简单地为每个任务都创建和销毁线程是一种进步，但是它并不能
消除由上下文切换所带来的开销，其将随着线程数量的增加很快变得明显，并且在高负载下愈演
愈烈。此外，仅仅由于应用程序的整体复杂性或者并发需求，在项目的生命周期内也可能会出现
其他和线程相关的问题。

Executor的执行逻辑

EventLoop

Netty 的EventLoop 是协同设计的一部分，它采用了两个基本的API：并发和网络编程。
首先，io.netty.util.concurrent 包构建在JDK 的java.util.concurrent 包上，用
来提供线程执行器。其次，io.netty.channel 包中的类，为了与Channel 的事件进行交互，
扩展了这些接口/类。

EventLoop类继承结构

在这个模型中，一个EventLoop 将由一个永远都不会改变的Thread 驱动，同时任务
（Runnable 或者Callable）可以直接提交给EventLoop 实现，以立即执行或者调度执行。
根据配置和可用核心的不同，可能会创建多个EventLoop 实例用以优化资源的使用，并且单个
EventLoop 可能会被指派用于服务多个Channel。

实现细节

Netty线程模型的卓越性能取决于对于当前执行的Thread的身份的确定，也就是说，确定它是否是分配给当前Channel以及它的EventLoop的那一个线程(EventLoop将负责处理一个Channel的整个生命周期内的所有事件)。

如果（当前）调用线程正是支撑EventLoop 的线程，那么所提交的代码块将会被（直接）
执行。否则，EventLoop 将调度该任务以便稍后执行，并将它放入到内部队列中。当EventLoop
下次处理它的事件时，它会执行队列中的那些任务/事件。这也就解释了Thread 是如何
与Channel 直接交互而无需在ChannelHandler 中进行额外同步的。

注意，每个EventLoop 都有它自已的任务队列，独立于任何其他的EventLoop。下图
展示了EventLoop 用于调度任务的执行逻辑。这是Netty 线程模型的关键组成部分。

EventLoop的执行逻辑

服务于Channel 的I/O 和事件的EventLoop 包含在EventLoopGroup 中。根据不同的
传输实现，EventLoop 的创建和分配方式也不同。

1. 异步传输

异步传输实现只使用了少量的EventLoop（以及和它们相关联的Thread），而且在当前的
线程模型中，它们可能会被多个Channel 所共享。这使得可以通过尽可能少量的Thread 来支
撑大量的Channel，而不是每个Channel 分配一个Thread。
图7-4 显示了一个EventLoopGroup，它具有3 个固定大小的EventLoop（每个EventLoop
都由一个Thread 支撑）。在创建EventLoopGroup 时就直接分配了EventLoop（以及支撑它们
的Thread），以确保在需要时它们是可用的。

用于非阻塞传输（如NIO 和AIO）的EventLoop 分配方式

EventLoopGroup 负责为每个新创建的Channel 分配一个EventLoop。在当前实现中，
使用顺序循环（round-robin）的方式进行分配以获取一个均衡的分布，并且相同的EventLoop
可能会被分配给多个Channel。（这一点在将来的版本中可能会改变。）

一旦一个Channel 被分配给一个EventLoop，它将在它的整个生命周期中都使用这个
EventLoop（以及相关联的Thread）。请牢记这一点，因为它可以使你从担忧你的Channel-
Handler 实现中的线程安全和同步问题中解脱出来。

另外，需要注意的是，EventLoop 的分配方式对ThreadLocal 的使用的影响。因为一个
EventLoop 通常会被用于支撑多个Channel，所以对于所有相关联的Channel 来说，
ThreadLocal 都将是一样的。这使得它对于实现状态追踪等功能来说是个糟糕的选择。然而，
在一些无状态的上下文中，它仍然可以被用于在多个Channel 之间共享一些重度的或者代价昂
贵的对象，甚至是事件。

2. 阻塞传输

用于像OIO（旧的阻塞I/O）这样的其他传输的设计略有不同，如图7-5 所示。这里每一个Channel 都将被分配给一个EventLoop（以及它的Thread）。如果你开发的应用程序使用过java.io 包中的阻塞I/O 实现，你可能就遇到过这种模型。

阻塞传输（如OIO）的EventLoop 分配方式

但是，正如同之前一样，得到的保证是每个Channel 的I/O 事件都将只会被一个Thread
（用于支撑该Channel 的EventLoop 的那个Thread）处理。这也是另一个Netty 设计一致性
的例子，它（这种设计上的一致性）对Netty 的可靠性和易用性做出了巨大贡献。

实现

介绍完Netty的线程模型后，让我看一下它是如何实现的。之前我们已经看到了EventLoop的类层级结构图，现在我们不管EventLoop，而是先看EventExecutorGroup以及对应的实现。

EventExecutorGroup

首先我们先明确一件事，EventExecutorGroup与常见的线程池类似，而EventExecutor虽然也继承了ExecutorService，但是它是一个特化的只维护一个线程的线程池，因此可以将其视为拥有线程池职能的线程。而一个EventExecutorGroup管理多个EventExecutor，此结构与我们熟悉的线程池模型更加相似。理解了这件事之后，关于EventExecutorGroup的实现将清晰许多。

EventExecutorGroup

AbstractEventExecutorGroup是EventExecutorGroup接口的基本实现，遵循前面的介绍的轮询(round-robin)模式，将每一个任务轮流分配给它所管理的EventExecutor。

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

/**
 * Returns one of the {@link EventExecutor}s managed by this {@link EventExecutorGroup}.
 */
EventExecutor next();

MultithreadEventExecutorGroup则实现了线程池的骨架，正如其名，它是一个支持多线程执行的EventExecutorGroup，与java.util.concurrent中实现的线程池类似。这个类的核心是它的构造方法，展现了它与EventExecutor之间是如何关联的：

private final EventExecutor[] children;


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

    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