原理剖析（第 011 篇）Netty之服务端启动工作原理分析(下)
一、大致介绍
1、由于篇幅过长难以发布，所以本章节接着上一节来的，上一章节为【原理剖析（第 010 篇）Netty之服务端启动工作原理分析(上)】；
2、那么本章节就继续分析Netty的服务端启动，分析Netty的源码版本为：netty-netty-4.1.22.Final；
二、三、四章节请看上一章节
详见 原理剖析（第 010 篇）Netty之服务端启动工作原理分析(上)
四、源码分析Netty服务端启动
上一章节，我们主要分析了一下线程管理组对象是如何被实例化的，并且还了解到了每个线程管理组都有一个子线程数组来处理任务；
那么接下来我们就直接从4.6开始分析了：
4.6、为serverBootstrap添加配置参数
1、源码：
// NettyServer.java
// 将 Boss、Worker 设置到 ServerBootstrap 服务端引导类中
serverBootstrap.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
// 指定通道类型为NioServerSocketChannel，一种异步模式，OIO阻塞模式为OioServerSocketChannel
.localAddress("localhost", port)//设置InetSocketAddress让服务器监听某个端口已等待客户端连接。
.childHandler(new ChannelInitializer<Channel>() {//设置childHandler执行所有的连接请求
@Override
protected void initChannel(Channel ch) throws Exception {
ch.pipeline().addLast(new PacketHeadDecoder());
ch.pipeline().addLast(new PacketBodyDecoder());
ch.pipeline().addLast(new PacketHeadEncoder());
ch.pipeline().addLast(new PacketBodyEncoder());
ch.pipeline().addLast(new PacketHandler());
}
});
2、主要为后序的通信设置了一些配置参数而已，指定构建的Channel为NioServerSocketChannel，说明需要启动的是服务端Netty；
而后面的服务端Channel实例化，就是需要通过这个参数反射实例化得到；
3、同时还设置childHandler，这个childHandler也是有顺序的，服务端读数据时执行的顺序是PacketHeadDecoder、PacketBodyDecoder、PacketHandler；
而服务端写数据时执行的顺序是PacketHandler、PacketBodyEncoder、PacketHeadEncoder；
所以在书写方式大家千万别写错了，按照本示例代码的方式书写即可；
4.7、serverBootstrap调用bind绑定注册
1、源码：
// NettyServer.java
// 最后绑定服务器等待直到绑定完成，调用sync()方法会阻塞直到服务器完成绑定,然后服务器等待通道关闭，因为使用sync()，所以关闭操作也会被阻塞。
ChannelFuture channelFuture = serverBootstrap.bind().sync();
2、这里其实没什么好看的，接下来我们就主要看看这个bind()方法主要干了些啥，就这么简简单单一句代码就把服务端给启动起来了，有点神气了；
4.8、bind()操作
1、源码：
// AbstractBootstrap.java
/**
* Create a new {@link Channel} and bind it.
*/
public ChannelFuture bind() {
validate();
SocketAddress localAddress = this.localAddress;
if (localAddress == null) {
throw new IllegalStateException("localAddress not set");
}
return doBind(localAddress); // 创建一个Channel，并且绑定它
}
// AbstractBootstrap.java
private ChannelFuture doBind(final SocketAddress localAddress) {
final ChannelFuture regFuture = initAndRegister(); // 初始化和注册
// 执行到此，服务端大概完成了以下几件事情：
// 1、实例化NioServerSocketChannel，并为Channel配备了pipeline、config、unsafe对象；
// 2、将多个handler添加至pipeline双向链表中，并且等待Channel注册成功后需要给每个handler触发添加或者移除事件；
// 3、将NioServerSocketChannel注册到NioEventLoop的多路复用器上；
final Channel channel = regFuture.channel();
if (regFuture.cause() != null) {
return regFuture;
}
// 既然NioServerSocketChannel的Channel绑定到了多路复用器上，那么接下来就是绑定地址，绑完地址就可以正式进行通信了
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;
}
}
2、大致一看，原来doBind方法主要干了两件事情，initAndRegister与doBind0；
3、initAndRegister主要做的事情就是初始化服务端Channel，并且将服务端Channel注册到bossGroup子线程的多路复用器上；
4、doBind0则主要完成服务端启动的最后一步，绑定地址，绑定完后就可以正式进行通信了；
4.9、initAndRegister()初始化和注册
1、源码：
// AbstractBootstrap.java
final ChannelFuture initAndRegister() {
Channel channel = null;
try {
// 反射调用clazz.getConstructor().newInstance()实例化类
// 同时也实例化了Channel，如果是服务端的话则为NioServerSocketChannel实例化对象
// 在实例化NioServerSocketChannel的构造方法中，也为每个Channel创建了一个管道属性对象DefaultChannelPipeline=pipeline对象
// 在实例化NioServerSocketChannel的构造方法中，也为每个Channel创建了一个配置属性对象NioServerSocketChannelConfig=config对象
// 在实例化NioServerSocketChannel的构造方法中，也为每个Channel创建了一个unsafe属性对象NioMessageUnsafe=unsafe对象
channel = channelFactory.newChannel(); // 调用ReflectiveChannelFactory的newChannel方法
// 初始化刚刚被实例化的channel
init(channel);
} catch (Throwable t) {
if (channel != null) {
// channel can be null if newChannel crashed (eg SocketException("too many open files"))
channel.unsafe().closeForcibly();
// as the Channel is not registered yet we need to force the usage of the GlobalEventExecutor
return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);
}
// as the Channel is not registered yet we need to force the usage of the GlobalEventExecutor
return new DefaultChannelPromise(new FailedChannel(), GlobalEventExecutor.INSTANCE).setFailure(t);
}
// config().group()=bossGroup或parentGroup，然后利用parentGroup去注册NioServerSocketChannel=channel
ChannelFuture regFuture = config().group().register(channel);
if (regFuture.cause() != null) {
if (channel.isRegistered()) {
channel.close();
} else {
channel.unsafe().closeForcibly();
}
}
// If we are here and the promise is not failed, it's one of the following cases:
// 1) If we attempted registration from the event loop, the registration has been completed at this point.
// i.e. It's safe to attempt bind() or connect() now because the channel has been registered.
// 2) If we attempted registration from the other thread, the registration request has been successfully
// added to the event loop's task queue for later execution.
// i.e. It's safe to attempt bind() or connect() now:
// because bind() or connect() will be executed *after* the scheduled registration task is executed
// because register(), bind(), and connect() are all bound to the same thread.
return regFuture;
}
2、逐行分析后会发现，首先通过反射实例化服务端channel对象，然后将服务端channel初始化一下；
3、然后调用bossGroup的注册方法，将服务端channel作为参数传入；
4、至此，方法名也表明该段代码的意图，实例化并初始化服务端Channel，然后注册到bossGroup子线程的多路复用器上；
4.10、init服务端Channel
1、源码：
// ServerBootstrap.java
@Override
void init(Channel channel) throws Exception {
final Map<ChannelOption<?>, Object> options = options0();
synchronized (options) {
setChannelOptions(channel, options, logger);
}
final Map<AttributeKey<?>, Object> attrs = attrs0();
synchronized (attrs) {
for (Entry<AttributeKey<?>, Object> e: attrs.entrySet()) {
@SuppressWarnings("unchecked")
AttributeKey<Object> key = (AttributeKey<Object>) e.getKey();
channel.attr(key).set(e.getValue());
}
}
// 服务端ServerSocketChannel的管道对象，Channel实例化的时候就被创建出来了
ChannelPipeline p = channel.pipeline();
final EventLoopGroup currentChildGroup = childGroup;
final ChannelHandler currentChildHandler = childHandler;
final Entry<ChannelOption<?>, Object>[] currentChildOptions;
final Entry<AttributeKey<?>, Object>[] currentChildAttrs;
synchronized (childOptions) {
currentChildOptions = childOptions.entrySet().toArray(newOptionArray(childOptions.size()));
}
synchronized (childAttrs) {
currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(childAttrs.size()));
}
ChannelInitializer<Channel> tempHandler = new ChannelInitializer<Channel>() {
@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() {
System.out.println("initAndRegister.init.initChannel-->ch.eventLoop().execute");
pipeline.addLast(new ServerBootstrapAcceptor(
ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
}
});
}
};
// 这里我将addLast的参数剥离出来了，方便查看阅读
p.addLast(tempHandler);
}
// DefaultChannelPipeline.java
@Override
public final ChannelPipeline addLast(ChannelHandler... handlers) {
return addLast(null, handlers);
}
// DefaultChannelPipeline.java
@Override
public final ChannelPipeline addLast(EventExecutorGroup executor, ChannelHandler... handlers) {
if (handlers == null) {
throw new NullPointerException("handlers");
}
for (ChannelHandler h: handlers) {
if (h == null) {
break;
}
addLast(executor, null, h);
}
return this;
}
// DefaultChannelPipeline.java
@Override
public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) {
final AbstractChannelHandlerContext newCtx;
// 这里加了synchronized关键字，因此说addLast的新增动作都是线程安全的
// 然后再细看一下其它的方法，只要涉及到的handler的增删改动作的方法，那些方法的代码块都是经过synchronized修饰了，保证操作过程中线程安全
synchronized (this) {
// 检查handler的一些基本信息，若不是被Sharable注解过的话，而且已经被添加到其他pipeline时则会抛出异常
checkMultiplicity(handler);
// 通过一系列参数的封装，最后封装成DefaultChannelHandlerContext对象
newCtx = newContext(group, filterName(name, handler), handler);
// 将newCtx添加到倒数第二的位置，即tail的前面一个位置
// 这里的pipeline中的handler的构成方式是一个双向链表式的结构
addLast0(newCtx);
// If the registered is false it means that the channel was not registered on an eventloop yet.
// In this case we add the context to the pipeline and add a task that will call
// ChannelHandler.handlerAdded(...) once the channel is registered.
// 该addLast方法可能会被其它各个地方调用，但是又为了保证handler的线程安全，则采用了synchronized来保证addLast的线程安全
// 在Channel未注册到多路复用器之前，registered肯定为false，那么则把需要添加的handler封装成AbstractChannelHandlerContext对象，
// 然后调用setAddPending方法，pengding意味着在将来的某个时刻调用，那到底在什么时刻被调用呢？
// 英文解释中提到一旦Channel注册成功了的话则会被调用，所以Channel后续注册完毕，再调用ChannelHandler.handlerAdded
if (!registered) {
newCtx.setAddPending();
// 将newCtx追加到PendingHandlerCallback单向链表的队尾，以便将来回调时用到
callHandlerCallbackLater(newCtx, true);
return this;
}
EventExecutor executor = newCtx.executor();
if (!executor.inEventLoop()) {
newCtx.setAddPending();
executor.execute(new Runnable() {
@Override
public void run() {
callHandlerAdded0(newCtx);
}
});
return this;
}
}
// 如果能顺利执行到这里来的话，则表明Channel已经注册到了NioEventLoop的多路复用器上面了
// 然后接下来的就是触发调用newCtx的ChannelHandler.handlerAdded方法
callHandlerAdded0(newCtx);
return this;
}
// DefaultChannelPipeline.java
private void addLast0(AbstractChannelHandlerContext newCtx) {
AbstractChannelHandlerContext prev = tail.prev; // 将目前双向链表tail的前驱结点找出来命名为prev
newCtx.prev = prev; // 将新的结点的前驱结点指向prev
newCtx.next = tail; // 将新的结点的后驱结点指向tail
prev.next = newCtx; // 将prev的后驱结点指向新的结点
tail.prev = newCtx; // 将tail的前驱结点指向新的结点
// 就这样，将新的结点通过一系列的指针指向，顺利的将新结点插到了tail的前面，
// 也就是链表中倒数第2个结点的位置，原链表中倒数第2个结点变成倒数第3个结点
}
// DefaultChannelPipeline.java
private void callHandlerCallbackLater(AbstractChannelHandlerContext ctx, boolean added) {
assert !registered;
// 根据added布尔值封装成PendingHandlerAddedTask、PendingHandlerRemovedTask对象
PendingHandlerCallback task = added ? new PendingHandlerAddedTask(ctx) : new PendingHandlerRemovedTask(ctx);
PendingHandlerCallback pending = pendingHandlerCallbackHead;
if (pending == null) { // 首次添加时则直接赋值然后返回
pendingHandlerCallbackHead = task;
} else {
// 非首次赋值的话，那么通过while循环找到队尾，然后将队尾的next指向赋上task对象
// Find the tail of the linked-list.
while (pending.next != null) {
pending = pending.next; // 不停的寻找链表中的下一个结点
}
// 当pending.next为空说明已经找到了队尾结点，然后将队尾的next指向赋上task对象
pending.next = task;
}
}
2、其实初始化服务端Channel也做了蛮多的事情，事情再多也只是p.addLast(tempHandler)这句代码干的事情多；
3、主要完成了服务端Channel中管道对象pipeline添加handler的操作，添加过程中主要有以下几点：
• 添加的过程中是由synchronized关键字来保证线程安全的；
• 将传入的handler数组依次循环封装成AbstractChannelHandlerContext对象添加到管道锁维护的handler链表中；
• 当未注册成功时pipeline还维护了一个用后后序触发调用newCtx的单向链表对象pendingHandlerCallbackHead；
• 当注册成功后，后序会迭代pendingHandlerCallbackHead对象依次执行所有任务的run方法；
• 当注册成功后，还会触发调用这些newCtx的一些方法，主要是newCtx的ChannelHandler.handlerAdded方法；
4、讲到这里，initAndRegister总算讲了一半了，接下来我们就要看看被实例化的服务端channel是如何注册到多路复用器上的；
4.11、config().group().register(channel)
1、源码：
// MultithreadEventLoopGroup.java
@Override
public ChannelFuture register(Channel channel) {
// next()对象其实是NioEventLoopGroup内部中的children[]属性中的其中一个，通过一定规则挑选一个NioEventLoop
// 那么也就是说我们最终调用的是NioEventLoop来实现注册channel
return next().register(channel);
// 从另外一个层面来讲，我们要想注册一个Channel，那么就可以直接调用NioEventLoopGroup父类中的register(Channel)即可注册Channel，
// 并且会按照一定的规则顺序通过next()挑选一个NioEventLoop并将Channel绑定到它上面
// 如果NioEventLoopGroup为bossGroup的话，那么该方法注册的肯定是NioServerSocketChannel对象
// 如果NioEventLoopGroup为workerGroup的话，那么该方法注册的肯定是ServerSocketChannel对象
}
// SingleThreadEventLoop.java
@Override
public ChannelFuture register(Channel channel) {
// 当前this对象是属于children[]属性中的其中一个
// 将传入的Channel与当前对象this一起封装成DefaultChannelPromise对象
// 然后再调用当前对象的register(ChannelPromise)注册方法
return register(new DefaultChannelPromise(channel, this));
}
// SingleThreadEventLoop.java
@Override
public ChannelFuture register(final ChannelPromise promise) {
// 校验当前传参是否为空，原则上既然是不可能为空的，因为上一个步骤是通过new出来的一个对象
ObjectUtil.checkNotNull(promise, "promise");
// promise.channel()其实就是上面new DefaultChannelPromise(channel, this)通过封装后又取出这个channel对象
// promise.channel().unsafe()而每个Channel都有一个unsafe对象，对于NioServerSocketChannel来说NioMessageUnsafe=unsafe
// 当前this对象是属于children[]属性中的其中一个
promise.channel().unsafe().register(this, promise);
return promise;
}
// AbstractUnsafe.java
@Override
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
// eventLoop对象是属于children[]属性中的其中一个
// 而当前类又是Channel的一个抽象类AbstractChannel，也是NioServerSocketChannel的父类
if (eventLoop == null) {
throw new NullPointerException("eventLoop");
}
if (isRegistered()) {
promise.setFailure(new IllegalStateException("registered to an event loop already"));
return;
}
if (!isCompatible(eventLoop)) {
promise.setFailure(
new IllegalStateException("incompatible event loop type: " + eventLoop.getClass().getName()));
return;
}
// 这里的 this.eventLoop 就是Children[i]中的一个，也就是具体执行任务的线程封装对象
AbstractChannel.this.eventLoop = eventLoop;
if (eventLoop.inEventLoop()) { // 如果对象eventLoop中的线程对象和当前线程比对是一样的话
register0(promise); // 那么则直接调用注册方法register0
} else {
try {
// 比对的结果如果不一样，十有八九都是该eventLoop的线程还未启动，
// 因此利用eventLoop的execute将register0(promise)方法作为任务添加到任务队列中，并启动线程来执行任务
eventLoop.execute(new Runnable() {
@Override
public void run() {
register0(promise);
}
});
// 而服务端Channel的注册，走的是该else分支，因为线程都还没创建，eventLoop.inEventLoop()肯定就是false结果
} catch (Throwable t) {
logger.warn(
"Force-closing a channel whose registration task was not accepted by an event loop: {}",
AbstractChannel.this, t);
closeForcibly();
closeFuture.setClosed();
safeSetFailure(promise, t);
}
}
}
// SingleThreadEventExecutor.java
/**
* 向任务队列中添加任务task。
*
* @param task
*/
@Override
public void execute(Runnable task) {
if (task == null) { // 如果传入的task任务为空，则直接抛空指针异常，此方法严格控制传入参数必须非空
throw new NullPointerException("task");
}
boolean inEventLoop = inEventLoop(); // 判断要添加的任务的这个线程，是不是和正在运行的nioEventLoop的处于同一个线程？
if (inEventLoop) { // 如果是，则说明就是当前线程正在添加task任务，那么则直接调用addTask方法添加到队列中
addTask(task); // 添加task任务
} else {
startThread(); // 如果不是当前线程，则看看实例化的对象nioEventLoop父类中state字段是否标识有新建线程，没有的话则利用线程池新创建一个线程，有的话则不用理会了
addTask(task); // 添加task任务
// 防止意外情况，还需要判断下是否被关闭掉，如果被关闭掉的话，则将刚刚添加的任务删除掉并采取拒绝策略直接抛出RejectedExecutionException异常
if (isShutdown() && removeTask(task)) {
reject(); // 拒绝策略直接抛出RejectedExecutionException异常
}
}
// addTaskWakesUp：添加任务时需要唤醒标志，默认值为false，通过构造方法传进来的也是false
// wakesUpForTask(task)：不是NonWakeupRunnable类型的task则返回true，意思就是只要不是NonWakeupRunnable类型的task，都需要唤醒阻塞操作
if (!addTaskWakesUp && wakesUpForTask(task)) {
wakeup(inEventLoop);
}
}
2、通过一路跟踪config().group().register(channel)该方法进去，最后会发现，源码会调用一个register0(promise)的代码来进行注册；
3、但是跳出来一看，细细回味config().group().register(channel)这段代码，可以得出这样的一个结论：
若以后大家想注册channel的话，直接通过线程管理组调用register方法，传入想要注册的channel对象即可；
4、当然还有一点请大家留意，execute(Runnable task)可以随意调用添加任务，如果线程已启动则直接添加，未启动的话则先启动线程再添加任务；
5、那么我们还是先尽快进入register0(promise)看看究竟是如何注册channel的；
4.12、register0(promise)
1、源码：
// AbstractUnsafe.java
private void register0(ChannelPromise promise) {
try {
// check if the channel is still open as it could be closed in the mean time when the register
// call was outside of the eventLoop
if (!promise.setUncancellable() || !ensureOpen(promise)) {
return;
}
boolean firstRegistration = neverRegistered;
doRegister(); // 调用Channel的注册方法，让Channel的子类AbstractNioChannel来实现注册
// 执行到此，说明Channel已经注册到了多路复用器上，并且也没有抛出什么异常，那么接下来就赋值变量表明已经注册成功
neverRegistered = false;
registered = true;
// Ensure we call handlerAdded(...) before we actually notify the promise. This is needed as the
// user may already fire events through the pipeline in the ChannelFutureListener.
pipeline.invokeHandlerAddedIfNeeded(); // 会回调initAndRegister中init方法的p.addLast的initChannel回调
safeSetSuccess(promise);
pipeline.fireChannelRegistered();
// Only fire a channelActive if the channel has never been registered. This prevents firing
// multiple channel actives if the channel is deregistered and re-registered.
if (isActive()) { // 检测Channel是否处于活跃状态，这里调用的是底层的socket的活跃状态
if (firstRegistration) {
pipeline.fireChannelActive(); // 这里也是注册成功后会仅仅只会被调用一次
} else if (config().isAutoRead()) {
// This channel was registered before and autoRead() is set. This means we need to begin read
// again so that we process inbound data.
//
// See https://github.com/netty/netty/issues/4805
beginRead(); // 设置Channel的读事件
}
}
} catch (Throwable t) {
// Close the channel directly to avoid FD leak.
closeForcibly();
closeFuture.setClosed();
safeSetFailure(promise, t);
}
}
// AbstractNioChannel.java
@Override
protected void doRegister() throws Exception {
boolean selected = false;
for (;;) { // 自旋式的死循环，如果正常操作不出现异常的话，那么则会一直尝试将Channel注册到多路复用器selector上面
try {
// eventLoop()对象是属于children[]属性中的其中一个，children是NioEventLoop类型的对象
// 而前面也了解到过，在实例化每个children的时候，会为每个children创建一个多路复用器selector与unwrappedSelector
selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);
// 如果将Channel注册到了多路复用器上的成功且没有抛什么异常的话，则返回跳出循环
return;
} catch (CancelledKeyException e) {
if (!selected) {
// Force the Selector to select now as the "canceled" SelectionKey may still be
// cached and not removed because no Select.select(..) operation was called yet.
eventLoop().selectNow();
selected = true;
} else {
// We forced a select operation on the selector before but the SelectionKey is still cached
// for whatever reason. JDK bug ?
throw e;
}
}
}
}
// DefaultChannelPipeline.java
final void invokeHandlerAddedIfNeeded() {
assert channel.eventLoop().inEventLoop();
if (firstRegistration) { // pipeline标识是否已注册，默认值为true
firstRegistration = false; // 马上置位false，告诉大家该方法只会被调用一次
// We are now registered to the EventLoop. It's time to call the callbacks for the ChannelHandlers,
// that were added before the registration was done.
// 到此为止，我们已经将Channel注册到了NioEventLoop的多路复用器上，那么接下来是时候回调Handler被添加进来
callHandlerAddedForAllHandlers();
}
}
// DefaultChannelPipeline.java
private void callHandlerAddedForAllHandlers() {
final PendingHandlerCallback pendingHandlerCallbackHead;
synchronized (this) {
assert !registered; // 测试registered是否为false，因为该方法已经表明只会被调用一次，所以这里就严格判断
// This Channel itself was registered.
registered = true; // 而且当registered设置为true后，就不会再改变该值的状态
pendingHandlerCallbackHead = this.pendingHandlerCallbackHead;
// Null out so it can be GC'ed.
this.pendingHandlerCallbackHead = null;
}
// This must happen outside of the synchronized(...) block as otherwise handlerAdded(...) may be called while
// holding the lock and so produce a deadlock if handlerAdded(...) will try to add another handler from outside
// the EventLoop.
PendingHandlerCallback task = pendingHandlerCallbackHead;
// 通过while循环，单向链表一个个回调task的execute，该回调添加的就回调添加，该回调移除的则回调移除
while (task != null) {
task.execute();
task = task.next;
}
}
2、看完register0(promise)是不是觉得，原来服务端channel的注册是这么简单，最后就是调用javaChannel().register(...)这个方法一下，然后就这么稀里糊涂的注册到多路复用器上了；
3、在注册完之际，还会找到之前的单向链表对象pendingHandlerCallbackHead，并且依依回调task.execute方法；
4、然后触发fireChannelRegistered注册成功事件，告知上层说我们的服务端channel已经注册成功了，大家请知悉一下；
5、最后通过beginRead设置服务端的读事件标志，就是说服务端的channel仅对读事件感兴趣；
6、至此initAndRegister这块算是讲完了，那么接下来就看看最后一个步骤绑定ip地址，完成通信前的最后一步；
4.13、doBind0(regFuture, channel, localAddress, promise)
1、源码：
// AbstractBootstrap.java
private static void doBind0(
final ChannelFuture regFuture, final Channel channel,
final SocketAddress localAddress, final ChannelPromise promise) {
// This method is invoked before channelRegistered() is triggered. Give user handlers a chance to set up
// the pipeline in its channelRegistered() implementation.
// 服务端启动最后一个步骤，绑完地址就可以正式进行通信了
channel.eventLoop().execute(new Runnable() {
@Override
public void run() {
if (regFuture.isSuccess()) {
// 服务端channel直接调用bind方法进行绑定地址
channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
} else {
promise.setFailure(regFuture.cause());
}
}
});
}
// AbstractChannel.java
@Override
public ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) {
return pipeline.bind(localAddress, promise);
}
// DefaultChannelPipeline.java
@Override
public final ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) {
return tail.bind(localAddress, promise);
}
// AbstractChannelHandlerContext.java
@Override
public ChannelFuture bind(final SocketAddress localAddress, final ChannelPromise promise) {
if (localAddress == null) {
throw new NullPointerException("localAddress");
}
if (isNotValidPromise(promise, false)) {
// cancelled
return promise;
}
final AbstractChannelHandlerContext next = findContextOutbound();
EventExecutor executor = next.executor();
if (executor.inEventLoop()) {
next.invokeBind(localAddress, promise);
} else {
safeExecute(executor, new Runnable() {
@Override
public void run() {
next.invokeBind(localAddress, promise);
}
}, promise, null);
}
return promise;
}
// AbstractChannelHandlerContext.java
private void invokeBind(SocketAddress localAddress, ChannelPromise promise) {
if (invokeHandler()) {
try {
((ChannelOutboundHandler) handler()).bind(this, localAddress, promise);
} catch (Throwable t) {
notifyOutboundHandlerException(t, promise);
}
} else {
bind(localAddress, promise);
}
}
// HeadContext.java
@Override
public void bind(
ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise)
throws Exception {
unsafe.bind(localAddress, promise);
}
// AbstractUnsafe.java
@Override
public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
assertEventLoop();
if (!promise.setUncancellable() || !ensureOpen(promise)) {
return;
}
// See: https://github.com/netty/netty/issues/576
if (Boolean.TRUE.equals(config().getOption(ChannelOption.SO_BROADCAST)) &&
localAddress instanceof InetSocketAddress &&
!((InetSocketAddress) localAddress).getAddress().isAnyLocalAddress() &&
!PlatformDependent.isWindows() && !PlatformDependent.maybeSuperUser()) {
// Warn a user about the fact that a non-root user can't receive a
// broadcast packet on *nix if the socket is bound on non-wildcard address.
logger.warn(
"A non-root user can't receive a broadcast packet if the socket " +
"is not bound to a wildcard address; binding to a non-wildcard " +
"address (" + localAddress + ") anyway as requested.");
}
boolean wasActive = isActive();
try {
doBind(localAddress);
} catch (Throwable t) {
safeSetFailure(promise, t);
closeIfClosed();
return;
}
if (!wasActive && isActive()) {
invokeLater(new Runnable() {
@Override
public void run() {
pipeline.fireChannelActive();
}
});
}
safeSetSuccess(promise);
}
// NioServerSocketChannel.java
@Override
protected void doBind(SocketAddress localAddress) throws Exception {
if (PlatformDependent.javaVersion() >= 7) {
javaChannel().bind(localAddress, config.getBacklog());
} else {
javaChannel().socket().bind(localAddress, config.getBacklog());
}
}
2、经过这么一路调用，其实最终会发现，绑定地址也是通过javaChannel().bind(...)这么简短的一句话就搞定了；
而前面的注册到多路复用器上调用的是javaChannel().register(...)一句简短代码；
从而可得出这么一个结论：只要关系到channel的注册绑定，最终核心底层都是调用这个channel的bind和register方法；
3、至此，服务端的启动流程算是完结了。。
五、总结
最后我们来总结下，通过分析Netty的服务端启动，经过的流程如下：
• 创建两个线程管理组，以及实例化每个线程管理组的子线程数组children[]；
• 设置启动类参数，比如channel、localAddress、childHandler等参数；
• 反射实例化NioServerSocketChannel，创建ChannelId、unsafe、pipeline等对象；
• 初始化NioServerSocketChannel，设置attr、option，添加新的handler到服务端pipeline管道中；
• 调用JDK底层做ServerSocketChannel注册到多路复用器上，并且注册成功后回调pipeline管道中的单向链表依次执行task任务；
• 调用JDK底层做NioServerSocketChannel绑定端口，并触发active事件；
六、下载地址
https://gitee.com/ylimhhmily/SpringCloudTutorial.git
SpringCloudTutorial交流QQ群: 235322432
SpringCloudTutorial交流微信群: 微信沟通群二维码图片链接
欢迎关注，您的肯定是对我最大的支持!!!
