吃透Netty源码系列三之bossGroup注册通道

向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里面就会提交一个任务，然后事件循环会去执行这个任务，这个会再下一篇文章里讲到：

至此注册流程基本结束，后续就看事件循环中的新线程如何运行了。
有张比较概括的流程图：

好了，今天就到这里了，希望对学习理解有帮助，大神看见勿喷，仅为自己的学习理解，能力有限，请多包涵。