在众多的编程语言和网络库中，拿来介绍网络编程的例子，echo服务器和客户端恐怕是最多的一个例子。netty作为一个在java语言中应用非常广泛、非常优秀的网络编程框架，echo服务器和客户端程序往往是大家第一个接触的实例程序。很多工程师正是通过echo服务器和客户端跨入netty的大门。
我们先看一个echo服务器的完整实例代码：
/**
* Echoes back any received data from a client.
*/
public final class EchoServer {
static final boolean SSL = System.getProperty("ssl") != null;
static final int PORT = Integer.parseInt(System.getProperty("port", "8007"));
public static void main(String[] args) throws Exception {
// Configure SSL.
final SslContext sslCtx;
if (SSL) {
SelfSignedCertificate ssc = new SelfSignedCertificate();
sslCtx = SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey()).build();
} else {
sslCtx = null;
}
// Configure the server.
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
// 把ServerBootstrap的channelfactory设置为ReflectiveChannelFactory
// 当执行channelfactory的newChannel方法时,会创建NioServerSocketChannel实例
.channel(NioServerSocketChannel.class)
.option(ChannelOption.SO_BACKLOG, 100)
// 处理server Socket事件
.handler(new LoggingHandler(LogLevel.INFO))
// 处理client socket事件
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
if (sslCtx != null) {
p.addLast(sslCtx.newHandler(ch.alloc()));
}
//p.addLast(new LoggingHandler(LogLevel.INFO));
p.addLast(new EchoServerHandler());
}
});
// Start the server.
ChannelFuture f = b.bind(PORT).sync();
// Wait until the server socket is closed.
f.channel().closeFuture().sync();
} finally {
// Shut down all event loops to terminate all threads.
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}
代码中前面一段跟SSL相关的代码我们先跳过，从这两行代码开始：
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
这里创建了两个EventLoopGroup对象bossGroup和workerGroup，bossGroup主要用来处理server socket监听client socket的连接请求，server socket接收了新建连接后，会把connection socket放到workerGroup中进行处理，也就是说workerGroup主要用来处理connection socket的网络IO和相关的业务逻辑。netty支持很多种线程模型，这种bossGroup和workerGroup的组合是比较典型的。
netty作为一个异步的事件驱动（event drivern）的网络应用程序框架，采用非阻塞的多路复用的网络io模型。连接建立、连接关闭、socket可读、socket可写这些状态的改变称为一个个“事件（event）”，当然事件也可以是应用程序添加的一个任务。而处理这些event的线程就是一个无限循环（for or while loop），没有事件发生时，线程一直等待事件的产生。当有事件发生时，则处理所有的事件，处理完后则开始下一个循环，继续等待新的事件的发生。所以这种处理逻辑叫做eventloop，eventloop与线程是一一对应的，一个eventloop对应一个线程，一个线程也只有一个eventloop。而eventloopgroup主要包含了一组eventloop（线程池），当然还有许多线程任务分发等管理功能。
eventloopgroup/eventloop是netty的核心部件之一，可以说是netty三大核心部件之一，另外两个是channel和pipeline。eventloopgroup/eventloop定义了netty的线程模型，包括channel对socket的操作、pipeline的业务处理、用户提交的任务在内的所有任务的分发调度和执行都是在eventloopgroup/eventloop中进行。
这里为eventloopgroup接口实例化的是类NioEventLoopGroup，NioEventLoopGroup基于java nio进行网络操作。
我们跟踪一下NioEventLoopGroup的构造函数，
NioEventLoopGroup
public NioEventLoopGroup(int nThreads) {
this(nThreads, (Executor) null);
}
public NioEventLoopGroup(int nThreads, Executor executor) {
this(nThreads, executor, SelectorProvider.provider());
}
public NioEventLoopGroup(
int nThreads, Executor executor, final SelectorProvider selectorProvider) {
this(nThreads, executor, selectorProvider, DefaultSelectStrategyFactory.INSTANCE);
}
public NioEventLoopGroup(int nThreads, Executor executor, final SelectorProvider selectorProvider,
final SelectStrategyFactory selectStrategyFactory) {
super(nThreads, executor, selectorProvider, selectStrategyFactory, RejectedExecutionHandlers.reject());
}
然后进入他的父类：
MultithreadEventLoopGroup
protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
}
继续进入上一级父类：
MultithreadEventExecutorGroup
protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
}
protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
EventExecutorChooserFactory chooserFactory, Object... args) {
}
这里进入了一个有实质内容的构造函数，在分析这个函数之前，我们先根据构造函数的调用链梳理一下构造函数的入参的值。
nThreads = (nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads);
executor = null;
chooserFactory = DefaultEventExecutorChooserFactory.INSTANCE;
args = [SelectorProvider SelectorProvider.provider(),
SelectStrategyFactory DefaultSelectStrategyFactory.INSTANCE,
RejectedExecutionHandler RejectedExecutionHandlers.reject()]
可见如果NioEventLoopGroup的构造函数如果nThreads为非0值，则为传入的实际值，如果为0或没有参数，则为DEFAULT_EVENT_LOOP_THREADS，我们看下DEFAULT_EVENT_LOOP_THREADS的定义，
DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
"io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2));
继续跟下去，可以知道NettyRuntime.availableProcessors()默认值为Runtime.getRuntime().availableProcessors()，也就是说nThreads值默认为CPU核心数的2倍
接下来我们分析构造函数:
protected MultithreadEventExecutorGroup(int nThreads, Executor executor, EventExecutorChooserFactory chooserFactory, Object... args)
首先为executor重新赋值:
if (executor == null) {
// DefaultThreadFactory设置: 非daemon、线程优先级5、线程名字、线程组为当前线程所属组
executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
}
因为executor入参值为null，所以executor重新赋值为ThreadPerTaskExecutor类的一个新建实例，ThreadPerTaskExecutor就是eventloop的执行器，eventloop的所有任务都是通过调用ThreadPerTaskExecutor的execute()函数，从而创建一个线程，进而执行提交的任务的。ThreadPerTaskExecutor只有一个成员，线程工厂DefaultThreadFactory,这个线程工厂创建的线程实例设置的线程属性为：非daemon、线程优先级5、线程名的前缀、所属的线程组与当前线程相同，一句话，创建的是一个普通线程，其中线程名的前缀为：
nioEventLoopGroup-poolId-, poolId初始值为0，每创建一个DefaultThreadFactory实例值加1。
然后初始化EventLoopGroup的线程池，具体代码如下：
// 创建一个数组，数组大小为线程的个数
children = new EventExecutor[nThreads];
for (int i = 0; i < nThreads; i ++) {
boolean success = false;
try {
// 初始化线程executor
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 {
// 如果初始化一个线程executor时抛出异常，则执行这一段代码：关闭前面创建的所有executor，并等待所有线程退出运行
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;
}
}
}
}
}
初始化过程，在代码注释中已经说明了，关键语句children[i] = newChild(executor, args);我们先放下，待会再详细分析。
线程选择器初始化：
chooser = chooserFactory.newChooser(children);
chooser实现了eventloopgroup的任务分派，当需要向线程池提交一个新的任务时，如注册一个新的服务端socket到eventloop，则通过chooser选择一个具体的executor。从前面分析得知，chooserFactory是DefaultEventExecutorChooserFactory的一个实例，它的executor选择逻辑代码如下：
public EventExecutorChooser newChooser(EventExecutor[] executors) {
if (isPowerOfTwo(executors.length)) {
return new PowerOfTwoEventExecutorChooser(executors);
} else {
return new GenericEventExecutorChooser(executors);
}
}
private static boolean isPowerOfTwo(int val) {
return (val & -val) == val;
}
private static final class PowerOfTwoEventExecutorChooser implements EventExecutorChooser {
private final AtomicInteger idx = new AtomicInteger();
private final EventExecutor[] executors;
PowerOfTwoEventExecutorChooser(EventExecutor[] executors) {
this.executors = executors;
}
@Override
// executor数是2的n次方，用与来计算，改善性能
public EventExecutor next() {
return executors[idx.getAndIncrement() & executors.length - 1];
}
}
private static final class GenericEventExecutorChooser implements EventExecutorChooser {
private final AtomicInteger idx = new AtomicInteger();
private final EventExecutor[] executors;
GenericEventExecutorChooser(EventExecutor[] executors) {
this.executors = executors;
}
@Override
// executor数不是2的n次方，用除法求余的方式计算
public EventExecutor next() {
return executors[Math.abs(idx.getAndIncrement() % executors.length)];
}
}
可见，线程池中的个数是2的n次方与不是2的n次方，具体的计算方法不一样，但效果都是round-robin的选择方法。
最后，为线程池的每一个EventExcutor注册一个结束后的回调函数，并把所有的EventExcutor保存到一个不可修改的Set中。具体代码如下：
// 线程结束时的回调函数
final FutureListener<Object> terminationListener = new FutureListener<Object>() {
@Override
public void operationComplete(Future<Object> future) throws Exception {
if (terminatedChildren.incrementAndGet() == children.length) {
terminationFuture.setSuccess(null);
}
}
};
// 注册回调函数
for (EventExecutor e: children) {
e.terminationFuture().addListener(terminationListener);
}
Set<EventExecutor> childrenSet = new LinkedHashSet<EventExecutor>(children.length);
Collections.addAll(childrenSet, children);
readonlyChildren = Collections.unmodifiableSet(childrenSet);
这个构造函数分析完了，下面分析eventloop以及它的初始化，也就是前面遗留没有分析的children[i] = newChild(executor, args); newChild是一个抽象函数：
protected abstract EventExecutor newChild(Executor executor, Object... args) throws Exception;
我们先看看类NioEventLoopGroup的继承体系：
然后从NioEventLoopGroup开始往上找哪个最底层的类实现了newChild()函数。
然后在类NioEventLoopGroup中找到了它的实现，
protected EventLoop newChild(Executor executor, Object... args) throws Exception {
return new NioEventLoop(this, executor, (SelectorProvider) args[0],
((SelectStrategyFactory) args[1]).newSelectStrategy(), (RejectedExecutionHandler) args[2]);
}
可见EventExecutor是NioEventLoop的一个实例，按照分析NioEventLoopGroup一样的分析过程，这里我不在粘贴具体代码了，只列出NioEventLoop的关键域的初始值，
NioEventLoop的继承体系：
关键域的初始值及说明：
SelectorProvider provider = SelectorProvider.provider()
Selector selector = provider.openSelector()
SelectStrategy selectStrategy = DefaultSelectStrategyFactory.INSTANCE
boolean addTaskWakesUp = false // 添加任务时不wakeup线程eventloop
int maxPendingTasks = Math.max(16,
SystemPropertyUtil.getInt("io.netty.eventLoop.maxPendingTasks", Integer.MAX_VALUE)); // 最小值为16，默认值为Integer.MAX_VALUE
Queue<Runnable> tailTasks = new LinkedBlockingQueue<Runnable>(maxPendingTasks)
Queue<Runnable> taskQueue = new LinkedBlockingQueue<Runnable>(maxPendingTasks)
EventExecutorGroup parent = 执行newChild函数的NioEventLoopGroup实例
Executor executor = ThreadPerTaskExecutor的实例
这里特别说明一下provider和selector。
provider在不同的操作系统平台下有不同的实现，windowns平台是WindowsSelectorProvider。在linux平台下，如果内核版本>=2.6则，具体的实现为EPollSelectorProvider，否则为默认的PollSelectorProvider。MAC平台下则是KQueueSelectorProvider。
selector是netty的一个核心概念，封装了不同平台的多路复用网络io模式，eventloop正是通过向selector注册感兴趣的事件（event），然后等待事件发生，从而实现非阻塞异步处理事件的目的。在linux平台下，底层通过epoll实现，执行provider.openSelector()可以理解为执行了epoll_init()系统调用，会返回一个epoll句柄给selector，然后通过selector可以向epoll注册感兴趣的事件，并在事件发生时获取发生的事件，然后对事件进行相应的处理。
