原理剖析（第 011 篇）Netty之服务端启动工作原理分析(下)

原理剖析（第 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交流微信群: 微信沟通群二维码图片链接

欢迎关注，您的肯定是对我最大的支持!!!