向bossGroup里注册通道
首先先看个基本的流程图吧，接下去再具体解析：
我们接着上篇继续，接下去就是注册通道了ChannelFuture regFuture = config().group().register(channel);：
@Override
public ChannelFuture register(Channel channel) {
return next().register(channel);
}
@Override
public EventLoop next() {
return (EventLoop) super.next();
}
@Override
public EventExecutor next() {
return chooser.next();
}
@Override
public EventExecutor next() {
return executors[idx.getAndIncrement() & executors.length - 1];
}
首先我们看next()，其实就前面讲过的选择器工厂DefaultEventExecutorChooserFactory，如何选择一个执行器。
然后选到了一个NioEventLoop，执行注册：
@Override
public ChannelFuture register(Channel channel) {
return register(new DefaultChannelPromise(channel, this));
}
创建了一个DefaultChannelPromise把通道和NioEventLoop都封装进去，DefaultChannelPromise是对Future做了加强，也是异步回调，可以设置很多监听，也可以将结果写入：
public ChannelFuture register(final ChannelPromise promise) {
ObjectUtil.checkNotNull(promise, "promise");
promise.channel().unsafe().register(this, promise);
return promise;
}
最后到了AbstractChannel的内部类AbstractUnsafe的注册方法：
Channel.Unsafe
这里的Unsafe不是JDK的Unsafe，是netty封装的Channel的内部类，为什么也叫Unsafe呢，因为他是一些操作NIO底层的方法，不建议外部用的,我们所说的把通道注册进bossGroup实际上就是调用他的实现类:
AbstractUnsafe.register
这个就是真正的注册方法：
@Override
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
...
AbstractChannel.this.eventLoop = eventLoop;//设置通道的事件循环，1对1，只设置一次
//只能当前线程是eventLoop的线程才可以注册，防止多线程并发问题，所以即使多线程来操作，也是安全的，会按照一定顺序提交到任务队列里
if (eventLoop.inEventLoop()) {
register0(promise);
} else {
try {
eventLoop.execute(new Runnable() {
@Override
public void run() {
register0(promise);
}
});
} catch (Throwable t) {
...
}
}
}
这里有个很巧妙的点，就是eventLoop.inEventLoop()这个的判断，就是判断调用这个方法的是不是eventLoop的线程，如果是，那就是同一个线程调用，直接就注册，否则属于多线程调用，可能会有问题，所以还是提交一个任务给eventLoop的线程去执行，这样就是单线程，不会有线程安全问题。
此时当前线程肯定不是事件循环里的线程，事件循环里的线程还没创建呢，所以会提交到队列：
eventLoop.execute
@Override
public void execute(Runnable task) {
ObjectUtil.checkNotNull(task, "task");
execute(task, !(task instanceof LazyRunnable) && wakesUpForTask(task));
}
这里会添加到任务队列去：
private void execute(Runnable task, boolean immediate) {
boolean inEventLoop = inEventLoop();
addTask(task);//添加任务到taskQueue
if (!inEventLoop) {//当前线程不是事件循环线程
startThread();//让线程工厂开启线程
...
}
if (!addTaskWakesUp && immediate) {
wakeup(inEventLoop);//唤醒线程，添加了一个空的任务去唤醒
}
}
startThread
然后启动线程，没启动就会启动：
private static final int ST_NOT_STARTED = 1;//没启动
private static final int ST_STARTED = 2;//启动了
private static final int ST_SHUTTING_DOWN = 3;//正在关闭中
private static final int ST_SHUTDOWN = 4;//关闭了
private static final int ST_TERMINATED = 5;//终止了
private void startThread() {
if (state == ST_NOT_STARTED) {
if (STATE_UPDATER.compareAndSet(this, ST_NOT_STARTED, ST_STARTED)) {
boolean success = false;
try {
doStartThread();//具体的开启线程
success = true;
} finally {
if (!success) {
STATE_UPDATER.compareAndSet(this, ST_STARTED, ST_NOT_STARTED);
}
}
}
}
}
doStartThread
其实里面就是调用SingleThreadEventExecutor.this.run();，这里其实executor.execute已经启动了新的线程来执行new Runnable()里的任务，也就是执行NioEventLoop. run()。
private void doStartThread() {
assert thread == null;
executor.execute(new Runnable() {
@Override
public void run() {
...
try {
SingleThreadEventExecutor.this.run();//这里就是关键
success = true;
} catch (Throwable t) {
logger.warn("Unexpected exception from an event executor: ", t);
} finally {
...//关闭相关
}
}
});
}
sync()
最后主线程如果完成了注册流程后，就会调用sync()尝试阻塞，调用的就是：
最终到了DefaultPromise的await()：
@Override
public Promise<V> await() throws InterruptedException {
if (isDone()) {//完成了就返回
return this;
}
if (Thread.interrupted()) {
throw new InterruptedException(toString());
}
checkDeadLock();
synchronized (this) {
while (!isDone()) {//判断是否完成
incWaiters();
try {
wait();//阻塞
} finally {
decWaiters();
}
}
}
return this;
}
可见如果这个时候注册和绑定端口完成了，就会返回了，否则就会wait();阻塞。
safeSetSuccess(promise);
绑定是事件循环的线程去做的，完成绑定后会调用safeSetSuccess(promise);方法，设置成功的结果，唤醒阻塞的主线程。最终是调用DefaultPromise的checkNotifyWaiters：
注册绑定监听并阻塞
阻塞被唤醒后，就注册一个监听的回调，然后阻塞关闭事件，其实就意味着不关闭就永远运行着了：
当然你也可以这样写，先添加监听，然后阻塞，反正结果都是一样的：
如果你的addListener是添加在同步后面的，此时可能事件循环线程已经完成了注册和绑定，addListener里面就会提交一个任务，然后事件循环会去执行这个任务，这个会再下一篇文章里讲到：
至此注册流程基本结束，后续就看事件循环中的新线程如何运行了。
有张比较概括的流程图：
好了，今天就到这里了，希望对学习理解有帮助，大神看见勿喷，仅为自己的学习理解，能力有限，请多包涵。
