说明：netty源码系列是基于4.1.25版本的netty源码的
Netty作为一个Java生态中的网络组件有着举足轻重的位置，各种开源中间件都使用Netty进行网络通信，比如Dubbo、RocketMQ。可以说Netty是对Java NIO的封装，比如ByteBuf、channel等的封装让网络编程更简单。
在介绍Netty服务器启动之前需要简单了解两件事：
- reactor线程模型
- linux中的IO多路复用
reactor线程模型
关于reactor线程模型请参考这篇文章，通过不同的配置Netty可以实现对应的三种reactor线程模型
- reactor单线程模型
- reactor多线程模型
- reactor主从多线程模型
// reactor单线程模型，accept、connect、read、write都在一个线程中执行
EventLoopGroup group = new NioEventLoopGroup(1);
bootStrap.group(group);
// reactor多线程，accept在bossGroup中的一个线程执行，IO操作在workerGroup中的线程执行
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
bootStrap.group(bossGroup , workerGroup);
// reactor主从多线程，用来accept连接的是在一个线程池中执行，这个时候需要bind多个port，因为Netty一个bind的port会启动一个线程来accept
EventLoopGroup bossGroup = new NioEventLoopGroup(2);
EventLoopGroup workerGroup = new NioEventLoopGroup();
bootStrap.group(bossGroup , workerGroup);
注意：本文后面的介绍如无特别说明都是基于reactor多线程模型
linux中的IO多路复用
linux中的网络编程模型也是在不断演变的，下面是依次演变的顺序（具体可参考《UNIX网络编程卷1：套接字联网API》第三版的第4、6章）
accept
阻塞等待连接，接收到新的连接后新起线程来处理接收到的连接，然后在新的线程中阻塞等待新的数据到来
select
根据入参的不同有三种情况
- 永远等下去，直到监听的描述符有任意的IO事件才返回
- 等待一段固定时间，如果时间到之前有IO事件则提前返回，否则等待超时后返回
- 不等待，检查描述符后立即返回，称为轮询
select会返回就绪的文件描述符的个数，需要轮询所有socket，判断每个socket的状态来确定是否有事件、是什么事件
poll
相比较于selectpoll是阻塞等待的，只有有读写事件的时候才会返回，返回的是有读写事件的socket个数，并且将对应的socket的事件置位，自己从所有socket中找到具体的socket
epoll
相比较于poll，epoll可以将只有确实有IO事件的描述符返回，大并发下只有少量活跃连接的情况下使用
较poll的优势
- 不用开发者重新准备文件描述符集合（较poll入参简单）
- 无需遍历所有监听的描述符，只要遍历哪些被内核IO事件异步唤醒而加入ready队列的描述符集合
Java NIO在linux的实现就是基于epoll的。epoll的编程模型：
- 创建socket，socket方法
- 绑定服务器ip，port，bind方法
- 监听绑定了ip:port的文件描述符，listen方法
- 创建epoll句柄（文件描述符），配置最大监听的文件描述符个数，epoll_create方法
- 配置epoll监听的文件描述符的事件：注册、修改、删除某个文件描述符对应的事件
- 监听所有已配置的描述符，epoll_wait
- 有新的事件的时候遍历返回的描述符，处理对应的事件
- 如果是来自客户端的连接，则将accept到的文件描述符注册到epoll中
- 如果是读写事件则分别处理
注意：Netty封装的Java NIO是跨平台的，后面还是以linux平台为例来介绍
接下来言归正传，来看看Netty的服务器启动过程做了什么事情。Netty作为一个网络框架，和普通网络编程做的事情基本上一样，对应于上面epoll的编程模型，Netty的启动过程为
- 初始化线程池，初始化selector
- 初始化NioServerSocketChannel
- 绑定服务器ip:port
- 将NioServerSocketChannel注册到selector中
- 配置NioServerSocketChannel监听的事件
- 使用selector.select等待新的IO事件
- 如果是来自客户端的连接则将NioSocketChannel注册到selector上（如果是新的线程则是新的selector）
- 如果是普通IO事件则在worker线程中处理
线程池初始化
在介绍NioEventLoopGroup之前先看下NioEventLoop
可以看到NioEventLoop继承自SingleThreadEventExecutor，是一个单线程的executor，在线程中死循环监听IO事件。主要方法有
// 初始化selector
io.netty.channel.nio.NioEventLoop#openSelector
// 将channel注册到selector
io.netty.channel.nio.NioEventLoop#register
// 监听selector上的事件
io.netty.channel.nio.NioEventLoop#select
一个NioEventLoop会初始化一个selector，处理selector上注册的channel。
NioEventLoopGroup从名字上就可以看出来是由多个NioEventLoop组成，类关系图如下
NioEventLoopGroup的重要属性为：
// 包含的EventExecutor数组
private final EventExecutor[] children;
// 选择哪一个EventExecutor执行task的选择器，不同的选择器有不同的策略
private final EventExecutorChooserFactory.EventExecutorChooser chooser;
重要方法有：
// 选择下一个执行任务的线程
io.netty.util.concurrent.MultithreadEventExecutorGroup#next
// 创建EventLoop
io.netty.channel.nio.NioEventLoopGroup#newChild
// 在线程池中执行注册channel的任务
io.netty.channel.MultithreadEventLoopGroup#register(io.netty.channel.Channel)
// 创建默认的threadFactory
io.netty.channel.MultithreadEventLoopGroup#newDefaultThreadFactory
线程池初始化的代码为
EventLoopGroup workerGroup = new NioEventLoopGroup();
如果使用无参的构造方法的话，最后会执行下面这个构造方法，这里面做要做了以下几件事
- 如果executor没有初始化，使用默认的executor初始化
- 初始化线程池中每个EventLoop
- 如果其中一个初始化过程中抛出异常，关闭所有的NioEventLoop
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 {
// 创建EventLoop
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，决定选择下一个线程的策略
chooser = chooserFactory.newChooser(children);
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);
}
使用默认参数构造参数的话，上面这个构造方法的入参的值分别是
nThreads
// 默认的线程池大小
private static final int DEFAULT_EVENT_LOOP_THREADS;
static {
// 如果配置了io.netty.eventLoopThreads参数的话，先取该参数的值
// 如果没有配置上面的参数，则取机器处理器个数的2倍
// 如果上面算出的结果小于1则取1
DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
"io.netty.eventLoopThreads", Runtime.getRuntime().availableProcessors() * 2));
if (logger.isDebugEnabled()) {
logger.debug("-Dio.netty.eventLoopThreads: {}", DEFAULT_EVENT_LOOP_THREADS);
}
}
// 默认没有指定线程池大小，取DEFAULT_EVENT_LOOP_THREADS
protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
}
executor
默认没有指定executor，为null
chooserFactory
protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
}
// io.netty.util.concurrent.DefaultEventExecutorChooserFactory
使用默认的chooser，该类的主要功能是提供选择下一个线程的策略
public final class DefaultEventExecutorChooserFactory implements EventExecutorChooserFactory {
// 单例
public static final DefaultEventExecutorChooserFactory INSTANCE = new DefaultEventExecutorChooserFactory();
private DefaultEventExecutorChooserFactory() { }
@SuppressWarnings("unchecked")
@Override
public EventExecutorChooser newChooser(EventExecutor[] executors) {
if (isPowerOfTwo(executors.length)) {
// 如果是2的幂次则使用这个chooser
return new PowerOfTowEventExecutorChooser(executors);
} else {
return new GenericEventExecutorChooser(executors);
}
}
private static boolean isPowerOfTwo(int val) {
// 判断一个数是否2的幂，方法很巧妙
return (val & -val) == val;
}
private static final class PowerOfTowEventExecutorChooser implements EventExecutorChooser {
private final AtomicInteger idx = new AtomicInteger();
private final EventExecutor[] executors;
PowerOfTowEventExecutorChooser(EventExecutor[] executors) {
this.executors = executors;
}
@Override
public EventExecutor next() {
// 如果是2的幂次个线程，可以使用位运算计算出下一个选出的线程的index
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
public EventExecutor next() {
// 使用求余的方法计算出下一个线程的index
return executors[Math.abs(idx.getAndIncrement() % executors.length)];
}
}
}
可以看出上面两个chooser计算出的最终结果是一致的，但是使用位运算更快一点，所以如果是线程池的大小刚好是2的幂次的话使用位运算的chooser。
args
// args[0]，下面方法返回的provider，在linux平台上默认是EPollSelectorProvider
java.nio.channels.spi.SelectorProvider#provider
// args[1]，决定eventLoop每次执行select还是执行队列中的任务
io.netty.channel.DefaultSelectStrategyFactory
// args[2]，等待队列满以后的拒绝策略
io.netty.util.concurrent.RejectedExecutionHandlers#REJECT
初始化NioEventLoopGroup过程主要是为了初始化线程池中每一个NioEventLoop，而每一个NioEventLoop包含一个selector。
初始化selector
接着上面说到的初始化NioEventLoop，调用newChild方法来初始化
// io.netty.channel.nio.NioEventLoopGroup#newChild
protected EventLoop newChild(Executor executor, Object... args) throws Exception {
// 下面这几个参数上面已经介绍过
return new NioEventLoop(this, executor, (SelectorProvider) args[0],
((SelectStrategyFactory) args[1]).newSelectStrategy(), (RejectedExecutionHandler) args[2]);
}
NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider,
SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler) {
// 调用父类构造方法初始化taskQueue，taskQueue的大小取Math.max(16, maxPendingTasks)
super(parent, executor, false, DEFAULT_MAX_PENDING_TASKS, rejectedExecutionHandler);
// 校验selectorProvider
if (selectorProvider == null) {
throw new NullPointerException("selectorProvider");
}
// 校验EventLoop每次执行的select策略是否为空
if (strategy == null) {
throw new NullPointerException("selectStrategy");
}
provider = selectorProvider;
// 初始化selector
selector = openSelector();
selectStrategy = strategy;
}
private Selector openSelector() {
final Selector selector;
try {
// 调用的是sun.nio.ch.EPollSelectorProvider#openSelector
// 返回的是sun.nio.ch.EPollSelectorImpl
selector = provider.openSelector();
} catch (IOException e) {
throw new ChannelException("failed to open a new selector", e);
}
// 是否使用SelectedSelectionKeySet优化，默认不禁用false
if (DISABLE_KEYSET_OPTIMIZATION) {
return selector;
}
// Netty优化过后的
final SelectedSelectionKeySet selectedKeySet = new SelectedSelectionKeySet();
// 尝试获取SelectorImpl对象，后续会使用反射操作这个类的属性
Object maybeSelectorImplClass = AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
try {
return Class.forName(
"sun.nio.ch.SelectorImpl",
false,
PlatformDependent.getSystemClassLoader());
} catch (ClassNotFoundException e) {
return e;
} catch (SecurityException e) {
return e;
}
}
});
// 确保有权限访问该类
if (!(maybeSelectorImplClass instanceof Class) ||
// ensure the current selector implementation is what we can instrument.
!((Class<?>) maybeSelectorImplClass).isAssignableFrom(selector.getClass())) {
if (maybeSelectorImplClass instanceof Exception) {
Exception e = (Exception) maybeSelectorImplClass;
logger.trace("failed to instrument a special java.util.Set into: {}", selector, e);
}
return selector;
}
final Class<?> selectorImplClass = (Class<?>) maybeSelectorImplClass;
Object maybeException = AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
try {
// 得到字段selectedKeys
Field selectedKeysField = selectorImplClass.getDeclaredField("selectedKeys");
// 得到字段publicSelectedKeys
Field publicSelectedKeysField = selectorImplClass.getDeclaredField("publicSelectedKeys");
selectedKeysField.setAccessible(true);
publicSelectedKeysField.setAccessible(true);
// 将selectedKeys、publicSelectedKeys均设置为Netty自定义的SelectedSelectionKeySet
selectedKeysField.set(selector, selectedKeySet);
publicSelectedKeysField.set(selector, selectedKeySet);
return null;
} catch (NoSuchFieldException e) {
return e;
} catch (IllegalAccessException e) {
return e;
} catch (RuntimeException e) {
// JDK 9 can throw an inaccessible object exception here; since Netty compiles
// against JDK 7 and this exception was only added in JDK 9, we have to weakly
// check the type
if ("java.lang.reflect.InaccessibleObjectException".equals(e.getClass().getName())) {
return e;
} else {
throw e;
}
}
}
});
if (maybeException instanceof Exception) {
selectedKeys = null;
Exception e = (Exception) maybeException;
logger.trace("failed to instrument a special java.util.Set into: {}", selector, e);
} else {
selectedKeys = selectedKeySet;
logger.trace("instrumented a special java.util.Set into: {}", selector);
}
return selector;
}
初始化selector的过程中主要做了几件事：
- 使用平台相关的provider初始化对应的SelectorImpl，这里使用了Java的SPI来加载平台相关的provider，每一种provider又对应一种SelectorImpl
- 如果没有禁用selectedKey优化，Netty会使用自定的SelectedSelectionKeySet替换SelectorImpl的publicSelectedKeys、selectedKeys
对SelectorImpl.selectedKey优化的说明
- 利用反射将SelectorImpl.selectedKey替换成了SelectedSelectionKeySet，SelectedSelectionKeySet利用数组实现元素存放
- 在调用select方法的时候如果有事件进来的时候会调用SelectedSelectionKeySet#add，将有IO事件的selectKey添加到keyset中
- 使用数组遍历（processSelectedKeysOptimized）要比使用set遍历快一些，参考文后第一篇参考文章
- 在Java9以后这个优化就失效了，因为Java9引入了Jigsaw
接下来看看Selector创建过程，上面调用了EPollSelectorProvider#openSelector来开始初始化selector
public AbstractSelector openSelector() throws IOException {
// 直接new 一个EPollSelectorImpl
return new EPollSelectorImpl(this);
}
// 该构造方法只能是包内使用，供provider来调用
EPollSelectorImpl(SelectorProvider sp) throws IOException {
// 调用父类SelectorImpl的构造方法初始化selectedKeys、publicKeys、publicSelectedKeys
// 上面已经说过了，如果使用Netty的优化，publicKeys、publicSelectedKey会被替换
super(sp);
// 调用linux的pipe方法，创建一个管道，配置为非阻塞的
long pipeFds = IOUtil.makePipe(false);
// 高32为读文件描述符
fd0 = (int) (pipeFds >>> 32);
// 低32位为写文件描述符
fd1 = (int) pipeFds;
// EPollArrayWrapper包含一系列native方法来调用EPollArrayWrapper.c本地方法
pollWrapper = new EPollArrayWrapper();
pollWrapper.initInterrupt(fd0, fd1);
// fdToKey用来保存文件描述符和SelectionKeyImpl的映射
fdToKey = new HashMap<>();
}
EPollArrayWrapper() throws IOException {
// creates the epoll file descriptor
// 创建epoll的文件描述符
epfd = epollCreate();
// the epoll_event array passed to epoll_wait
int allocationSize = NUM_EPOLLEVENTS * SIZE_EPOLLEVENT;
pollArray = new AllocatedNativeObject(allocationSize, true);
pollArrayAddress = pollArray.address();
// eventHigh needed when using file descriptors > 64k
if (OPEN_MAX > MAX_UPDATE_ARRAY_SIZE)
eventsHigh = new HashMap<>();
}
终于看到创建epoll文件描述符相关代码了，上面这个还是看不到究竟调用了哪些本地方法，我们看看相关的c代码
// jdk/src/solaris/native/sun/nio/ch/IOUtil.c
JNIEXPORT jlong JNICALL
Java_sun_nio_ch_IOUtil_makePipe(JNIEnv *env, jobject this, jboolean blocking)
{
int fd[2];
// 打开pipe
if (pipe(fd) < 0) {
JNU_ThrowIOExceptionWithLastError(env, "Pipe failed");
return 0;
}
if (blocking == JNI_FALSE) {
// 配置管道为非阻塞
if ((configureBlocking(fd[0], JNI_FALSE) < 0)
|| (configureBlocking(fd[1], JNI_FALSE) < 0)) {
JNU_ThrowIOExceptionWithLastError(env, "Configure blocking failed");
close(fd[0]);
close(fd[1]);
return 0;
}
}
// 将读写文件描述符放入一个long型中返回
return ((jlong) fd[0] << 32) | (jlong) fd[1];
}
// jdk/src/solaris/native/sun/nio/ch/EPollArrayWrapper.c
JNIEXPORT jint JNICALL
Java_sun_nio_ch_EPollArrayWrapper_epollCreate(JNIEnv *env, jobject this)
{
/*
* epoll_create expects a size as a hint to the kernel about how to
* dimension internal structures. We can't predict the size in advance.
*/
// 这里调用linux函数epoll_create创建epoll的文件描述符
int epfd = epoll_create(256);
if (epfd < 0) {
JNU_ThrowIOExceptionWithLastError(env, "epoll_create failed");
}
return epfd;
}
总结
经过上面说明，现在对于Netty启动过程中线程池的初始化过程和selector初始化过程已经比较清晰了，对于native方法的分析让我们对比linux中epoll编程，对于原理更加清楚。
接下来就是将需要监听的描述符注册到epoll上，对应到Netty就是讲channel注册到selector上，下一篇文章继续写Netty源码—二、server启动（2）
参考
Netty源码分析——Reactor的processSelectedKeys
关于SelectedSelectionKeySet优化的讨论
https://github.com/netty/netty/issues/2363
https://github.com/netty/netty/commit/cd579f75d2b5f236f35bc47f454cc07e50ae8037