本文是基于4.1.24-final版本，首先我们编写个测试例子，然后根据例子一步步debug过程中阅读源码。
EventLoopGroup bossGroup=new NioEventLoopGroup(1);
EventLoopGroup workerGroup=new NioEventLoopGroup();
try {
ServerBootstrap b=new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
public void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast(new EchoServerHandler());
};
})
.option(ChannelOption.SO_BACKLOG, 128)
.childOption(ChannelOption.SO_KEEPALIVE, true);
ChannelFuture f=b.bind(port).sync();
f.channel().closeFuture().sync();
}finally{
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}首先看下NioEventLoopGroup这个类，其关系图如下:
其构造函数最终会调用到MultithreadEventExecutorGroup:
protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
EventExecutorChooserFactory chooserFactory, Object... args) {
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) {
......
} finally {
...省略
}
}
chooser = chooserFactory.newChooser(children);
...省略
}默认的线程数为cpu processor size*2,主要看下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实例，我们看下这个类:
一个NioEventLoop可以看成是一单线程，线程不停的从队列中获取任务执行,我们来看下其run方法:
protected void run() {
for (;;) {
try {
switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {
case SelectStrategy.CONTINUE:
continue;
case SelectStrategy.SELECT:
select(wakenUp.getAndSet(false));
if (wakenUp.get()) {
selector.wakeup();
}
default:
}
cancelledKeys = 0;
needsToSelectAgain = false;
final int ioRatio = this.ioRatio;
if (ioRatio == 100) {
try {
processSelectedKeys();
} finally {
runAllTasks();
}
} else {
final long ioStartTime = System.nanoTime();
try {
processSelectedKeys();
} finally {
final long ioTime = System.nanoTime() - ioStartTime;
runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
}
}
} catch (Throwable t) {
handleLoopException(t);
}
........
}
} public int calculateStrategy(IntSupplier selectSupplier, boolean hasTasks) throws Exception {
return hasTasks ? selectSupplier.get() : SelectStrategy.SELECT;
}private void select(boolean oldWakenUp) throws IOException {
Selector selector = this.selector;
try {
int selectCnt = 0;
long currentTimeNanos = System.nanoTime();
long selectDeadLineNanos = currentTimeNanos + delayNanos(currentTimeNanos);
for (;;) {
long timeoutMillis = (selectDeadLineNanos - currentTimeNanos + 500000L) / 1000000L;
if (timeoutMillis <= 0) {
if (selectCnt == 0) {
selector.selectNow();
selectCnt = 1;
}
break;
}
if (hasTasks() && wakenUp.compareAndSet(false, true)) {
selector.selectNow();
selectCnt = 1;
break;
}
int selectedKeys = selector.select(timeoutMillis);
selectCnt ++;
if (selectedKeys != 0 || oldWakenUp || wakenUp.get() || hasTasks() || hasScheduledTasks()) {
break;
}
if (Thread.interrupted()) {
selectCnt = 1;
break;
}
long time = System.nanoTime();
if (time - TimeUnit.MILLISECONDS.toNanos(timeoutMillis) >= currentTimeNanos) {
selectCnt = 1;
} else if (SELECTOR_AUTO_REBUILD_THRESHOLD > 0 &&
selectCnt >= SELECTOR_AUTO_REBUILD_THRESHOLD) {
rebuildSelector();
selector = this.selector;
selector.selectNow();
selectCnt = 1;
break;
}
currentTimeNanos = time;
}
if (selectCnt > MIN_PREMATURE_SELECTOR_RETURNS) {
if (logger.isDebugEnabled()) {
logger.debug("Selector.select() returned prematurely {} times in a row for Selector {}.",
selectCnt - 1, selector);
}
}
} catch (CancelledKeyException e) {
........
}// If a task was submitted when wakenUp value was true, the task didn't get a chance to call
// Selector#wakeup. So we need to check task queue again before executing select operation.
// If we don't, the task might be pended until select operation was timed out.
// It might be pended until idle timeout if IdleStateHandler existed in pipeline.
if (hasTasks() && wakenUp.compareAndSet(false, true)) {
selector.selectNow();
selectCnt = 1;
break;
}看下ServerBootstrap,我们这里采用的默认构造函数，所以接着看代码下一行,我们看下这个group方法是干啥的：
public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
super.group(parentGroup);
if (childGroup == null) {
throw new NullPointerException("childGroup");
}
if (this.childGroup != null) {
throw new IllegalStateException("childGroup set already");
}
this.childGroup = childGroup;
return this;
}父类持有bossGroup,子类ServerBootstrap的childGroup就是我们的workGroup，这里采用了builder模式,在可选参数比较多的时候，builder模式能够大大派上用场。
接着channel方法将NioServerSocketChannel类放入到ChannelFactory中，用于后续通过反射构造NioServerSocketChannel实例。
接下来就是设置ServerBootstrap 的childHandler，这里我们标记为ChannelHandler-ChannelInitializer-1
接着ChannelOption.SO_BACKLOG用于构造服务端套接字ServerSocket对象，标识当服务器请求处理线程全满时，用于临时存放已完成三次握手的请求的队列的最大长度。
ChannelOption.SO_KEEPALIVE表示是否启用心跳保活机制。在双方TCP套接字建立连接后（即都进入ESTABLISHED状态）并且在两个小时左右上层没有任何数据传输的情况下，这套机制才会被激活。
接下来我们看下bind方法:
private ChannelFuture doBind(final SocketAddress localAddress) {
final ChannelFuture regFuture = initAndRegister();//1
final Channel channel = regFuture.channel();
if (regFuture.cause() != null) {
return regFuture;
}
if (regFuture.isDone()) {
// At this point we know that the registration was complete and successful.
ChannelPromise promise = channel.newPromise();
doBind0(regFuture, channel, localAddress, promise);
return promise;
} else {
// Registration future is almost always fulfilled already, but just in case it's not.
final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
regFuture.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
Throwable cause = future.cause();
if (cause != null) {
// Registration on the EventLoop failed so fail the ChannelPromise directly to not cause an
// IllegalStateException once we try to access the EventLoop of the Channel.
promise.setFailure(cause);
} else {
// Registration was successful, so set the correct executor to use.
// See https://github.com/netty/netty/issues/2586
promise.registered();
doBind0(regFuture, channel, localAddress, promise);
}
}
});
return promise;
}
}首先看下initAndRegister，省略部分代码:
final ChannelFuture initAndRegister() {
Channel channel = null;
channel = channelFactory.newChannel();
init(channel);
....
ChannelFuture regFuture = config().group().register(channel);
....
}首先第一步通过channelFactory创建NioServerSocketChannel实例，我们首先来看下这个类的关系图：
我们来看下它的构造函数:
public NioServerSocketChannel() {
this(newSocket(DEFAULT_SELECTOR_PROVIDER));
}public NioServerSocketChannel(ServerSocketChannel channel) {
super(null, channel, SelectionKey.OP_ACCEPT);//感兴趣的事件是accept
config = new NioServerSocketChannelConfig(this, javaChannel().socket());
}protected AbstractChannel(Channel parent) {
this.parent = parent;
id = newId();
unsafe = newUnsafe();
pipeline = newChannelPipeline();
}此时的parent=null,我们首先看下newUnsafe,主要是构造NioMessageUnsafe实例，它主要提供了read方法，用于读事件，后面我们会看到。
接着看下pipeline,它是DefaultChannelPipeline类的实例，它维护了双向一个链表，链表中元素类型为AbstractChannelHandlerContext，用于处理channelInbound和channeloutbound:
protected DefaultChannelPipeline(Channel channel) {
this.channel = ObjectUtil.checkNotNull(channel, "channel");
succeededFuture = new SucceededChannelFuture(channel, null);
voidPromise = new VoidChannelPromise(channel, true);
tail = new TailContext(this);
head = new HeadContext(this);
head.next = tail;
tail.prev = head;
}
final class TailContext extends AbstractChannelHandlerContext implements ChannelInboundHandler {
TailContext(DefaultChannelPipeline pipeline) {
super(pipeline, null, TAIL_NAME, true, false);
setAddComplete();
}
}
final class HeadContext extends AbstractChannelHandlerContext
implements ChannelOutboundHandler, ChannelInboundHandler {
private final Unsafe unsafe;
HeadContext(DefaultChannelPipeline pipeline) {
super(pipeline, null, HEAD_NAME, false, true);
unsafe = pipeline.channel().unsafe();
setAddComplete();
}
}
TailContext是一个inbound处理器，HeadContext是一个outbound处理器。所以此时pipeline中所维护的channelHandlerContext链表如下：
回到NioServerSocketChannel的构造函数，接下来就是构造NioServerSocketChannelConfig实例，这里我们先看下这个类的关系图，
接着往下看，回到initAndRegister方法，接下来看init方法:
void init(Channel channel) throws Exception {
.........
ChannelPipeline p = channel.pipeline();
final EventLoopGroup currentChildGroup = childGroup;//即workerGroup
final ChannelHandler currentChildHandler = childHandler;//即ChannelHandler-ChannelInitializer-1
.........
p.addLast(new ChannelInitializer<Channel>() {//这里我们标记为ChannelHandler-ChannelInitializer-2
@Override
public void initChannel(final Channel ch) throws Exception {
final ChannelPipeline pipeline = ch.pipeline();
ChannelHandler handler = config.handler();
if (handler != null) {
pipeline.addLast(handler);
}
ch.eventLoop().execute(new Runnable() {
@Override
public void run() {
pipeline.addLast(new ServerBootstrapAcceptor(
ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
}
});
}
});
}上图括号中是我加入的标记，用以区分过程中产生的匿名类实例.接下来回到initAndRegister方法中，看这行代码：
ChannelFuture regFuture = config().group().register(channel);public final void register(EventLoop eventLoop, final ChannelPromise promise) {
.......
AbstractChannel.this.eventLoop = eventLoop;//boss对应的NioEventLoop
if (eventLoop.inEventLoop()) {//初始时线程还没有启动
register0(promise);
} else {
try {
eventLoop.execute(new Runnable() {
@Override
public void run() {
register0(promise);
}
});
} catch (Throwable t) {
......
}
}
}private void register0(ChannelPromise promise) {
try {
boolean firstRegistration = neverRegistered;
doRegister();
neverRegistered = false;
registered = true;
pipeline.invokeHandlerAddedIfNeeded();
pipeline.fireChannelRegistered();
if (isActive()) {
if (firstRegistration) {
pipeline.fireChannelActive();
} else if (config().isAutoRead()) {
beginRead();
}
}
} catch (Throwable t) {
.....
}
}doRegister就是调用 ServerSocket进行注册(jdk)，就是把当前的NioServerSocketChannel实例与selector建立一定的关联关系。接着往下看，pipeline.invokeHandlerAddedIfNeeded最终会往boss对应的线程中添加任务，该任务就是往pipeline中添加新的context，这个步骤也是异步的,最终会进入到下面的调用:
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
if (ctx.channel().isRegistered()) {
initChannel(ctx);
}
}initChannel这个函数会调用到标记"ChannelHandler-ChannelInitializer-2"的initChannel方法,在这个任务中，向boss线程添加了一个任务，这个任务是向pipeline中添加一个context ServerBootstrapAcceptor，它也是一个inboundHandler,然后把"ChannelHandler-ChannelInitializer-2"，从pipeline中删除，ServerBootstrapAcceptor还在任务队列中还没有添加到pipeline中，此时pipeline中维护的链表如下:
接着往下看,pipeline.fireChannelRegistered()，最终会调用到invokeChannelRegistered(findContextInbound()),此时pipeline中只有一个inboundHandler,那就是TailContext,会调用到它的channelRegistered方法，这里什么都没做。接下来就死bind了主要在doBind0方法中,最终会调用unsafe.bind方法，
public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
boolean wasActive = isActive();
try {
doBind(localAddress);
} catch (Throwable t) {
......
}
if (!wasActive && isActive()) {
invokeLater(new Runnable() {
@Override
public void run() {
pipeline.fireChannelActive();
}
});
}
.....
}public void channelActive(ChannelHandlerContext ctx) throws Exception {
ctx.fireChannelActive();
readIfIsAutoRead();
}注意，此时pipeline中维护的链表如下:
ctx.fireChannelActive会找出当前的第一个inboundHandler(从左到右),然后执行其channelActive,实际来看，这里目前啥都没做。继续看下一行readIfIsAutoRead()，会调用到AbstractNioUnsafe.doBeginRead:
protected void doBeginRead() throws Exception {
final SelectionKey selectionKey = this.selectionKey;
if (!selectionKey.isValid()) {
return;
}
readPending = true;
final int interestOps = selectionKey.interestOps();//此时的值为0
if ((interestOps & readInterestOp) == 0) {
selectionKey.interestOps(interestOps | readInterestOp);//readInterestOp就是OP_ACCEPT
}
}其实就是注册感兴趣的事件accept等待连接到来，即打开的通道NioServerSocket感兴趣的事件是accept！
至此，netty服务端的流程算是启动完成了，下面我们来总结一下:
1，netty启动时主要是boss线程在执行一系列的操作，其初始化与注册等都是封装成一个个任务扔到线程队列中执行。线程主要处理两件事，一是处理感兴趣的事件，二是执行队列中的任务
2，netty的nio主要是将NioServerSocketChannel与selector绑定，然后向通道上注册感兴趣的事件，然后在boss线程中不断轮寻是否有感兴趣的事件到来。