1. 程式人生 > >netty原始碼分析之服務端啟動

netty原始碼分析之服務端啟動

ServerBootstrap與Bootstrap分別是netty中服務端與客戶端的引導類,主要負責服務端與客戶端初始化、配置及啟動引導等工作,接下來我們就通過netty原始碼中的示例對ServerBootstrap與Bootstrap的原始碼進行一個簡單的分析。首先我們知道這兩個類都繼承自AbstractBootstrap類

 

 

接下來我們就通過netty原始碼中ServerBootstrap的例項入手對其進行一個簡單的分析。

         // Configure the server.
        EventLoopGroup bossGroup = new
NioEventLoopGroup(1); EventLoopGroup workerGroup = new NioEventLoopGroup(); final EchoServerHandler serverHandler = new EchoServerHandler(); try { //初始化一個服務端引導類 ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup, workerGroup) //設定執行緒組
.channel(NioServerSocketChannel.class)//設定ServerSocketChannel的IO模型 分為epoll與Nio .option(ChannelOption.SO_BACKLOG, 100)//設定option引數,儲存成一個LinkedHashMap<ChannelOption<?>, Object>() .handler(new LoggingHandler(LogLevel.INFO))//這個hanlder 只專屬於 ServerSocketChannel 而不是 SocketChannel。
.childHandler(new ChannelInitializer<SocketChannel>() { //這個handler 將會在每個客戶端連線的時候呼叫。供 SocketChannel 使用。 @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline p = ch.pipeline(); if (sslCtx != null) { p.addLast(sslCtx.newHandler(ch.alloc())); } //p.addLast(new LoggingHandler(LogLevel.INFO)); p.addLast(serverHandler); } }); // Start the server. 啟動服務 ChannelFuture f = b.bind(PORT).sync(); // Wait until the server socket is closed. f.channel().closeFuture().sync(); } finally { // Shut down all event loops to terminate all threads. bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); }

 接下來我們主要從服務端的socket在哪裡初始化與哪裡accept連線這兩個問題入手對netty服務端啟動的流程進行分析;

 我們首先要知道,netty服務的啟動其實可以分為以下四步:

  • 建立服務端Channel
  • 初始化服務端Channel
  • 註冊Selector
  • 埠繫結

一、建立服務端Channel

1、服務端Channel的建立,主要為以下流程

我們通過跟蹤程式碼能夠看到

final ChannelFuture regFuture = initAndRegister();// 初始化並建立 NioServerSocketChannel

我們在initAndRegister()中可以看到channel的初始化。

channel = channelFactory.newChannel(); // 通過 反射工廠建立一個 NioServerSocketChannel

 我進一步看newChannel()中的原始碼,在ReflectiveChannelFactory這個反射工廠中,通過clazz這個類的反射建立了一個服務端的channel。

    @Override
    public T newChannel() {
        try {
            return clazz.getConstructor().newInstance();//反射建立
        } catch (Throwable t) {
            throw new ChannelException("Unable to create Channel from class " + clazz, t);
        }
    }

既然通過反射,我們就要知道clazz類是什麼,那麼我我們來看下channelFactory這個工廠類是在哪裡初始化的,初始化的時候我們傳入了哪個channel。

這裡我們需要看下demo例項中初始化ServerBootstrap時.channel(NioServerSocketChannel.class)這裡的具體實現,我們看下原始碼

    public B channel(Class<? extends C> channelClass) {
        if (channelClass == null) {
            throw new NullPointerException("channelClass");
        }
        return channelFactory(new ReflectiveChannelFactory<C>(channelClass));
    }

通過上面的程式碼我可以直觀的看出正是在這裡我們通過NioServerSocketChannel這個類構造了一個反射工廠。

那麼到這裡就很清楚了,我們建立的Channel就是一個NioServerSocketChannel,那麼具體的建立我們就需要看下這個類的建構函式。首先我們看下一個NioServerSocketChannel建立的具體流程

首先是newsocket(),我們先看下具體的程式碼,在NioServerSocketChannel的建構函式中我們建立了一個jdk原生的ServerSocketChannel

    /**
     * Create a new instance
     */
    public NioServerSocketChannel() {
        this(newSocket(DEFAULT_SELECTOR_PROVIDER));//傳入預設的SelectorProvider
    }

    private static ServerSocketChannel newSocket(SelectorProvider provider) {
        try {
            /**
             *  Use the {@link SelectorProvider} to open {@link SocketChannel} and so remove condition in
             *  {@link SelectorProvider#provider()} which is called by each ServerSocketChannel.open() otherwise.
             *
             *  See <a href="https://github.com/netty/netty/issues/2308">#2308</a>.
             */
            return provider.openServerSocketChannel();//可以看到建立的是jdk底層的ServerSocketChannel 
        } catch (IOException e) {
            throw new ChannelException(
                    "Failed to open a server socket.", e);
        }
    }

    

第二步是通過NioServerSocketChannelConfig配置服務端Channel的建構函式,在程式碼中我們可以看到我們把NioServerSocketChannel這個類傳入到了NioServerSocketChannelConfig的建構函式中進行配置

    /**
     * Create a new instance using the given {@link ServerSocketChannel}.
     */
    public NioServerSocketChannel(ServerSocketChannel channel) {
        super(null, channel, SelectionKey.OP_ACCEPT);//呼叫父類建構函式,傳入建立的channel
        config = new NioServerSocketChannelConfig(this, javaChannel().socket());
    }

第三步在父類AbstractNioChannel的建構函式中把建立服務端的Channel設定為非阻塞模式

    /**
     * Create a new instance
     *
     * @param parent            the parent {@link Channel} by which this instance was created. May be {@code null}
     * @param ch                the underlying {@link SelectableChannel} on which it operates
     * @param readInterestOp    the ops to set to receive data from the {@link SelectableChannel}
     */
    protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
        super(parent);
        this.ch = ch;//這個ch就是傳入的通過jdk建立的Channel
        this.readInterestOp = readInterestOp;
        try {
            ch.configureBlocking(false);//設定為非阻塞
        } catch (IOException e) {
            try {
                ch.close();
            } catch (IOException e2) {
                if (logger.isWarnEnabled()) {
                    logger.warn(
                            "Failed to close a partially initialized socket.", e2);
                }
            }

            throw new ChannelException("Failed to enter non-blocking mode.", e);
        }
    }

第四步呼叫AbstractChannel這個抽象類的建構函式設定Channel的id(每個Channel都有一個id,唯一標識),unsafe(tcp相關底層操作),pipeline(邏輯鏈)等,而不管是服務的Channel還是客戶端的Channel都繼承自這個抽象類,他們也都會有上述相應的屬性。我們看下AbstractChannel的建構函式

    /**
     * Creates a new instance.
     *
     * @param parent
     *        the parent of this channel. {@code null} if there's no parent.
     */
    protected AbstractChannel(Channel parent) {
        this.parent = parent;
        id = newId();//建立Channel唯一標識 
        unsafe = newUnsafe();//netty封裝的TCP 相關操作類
        pipeline = newChannelPipeline();//邏輯鏈
    }

 2、初始化服務端建立的Channel

init(channel);// 初始化這個 NioServerSocketChannel

我們首先列舉下init(channel)中具體都做了哪了些功能:

  • 設定ChannelOptions、ChannelAttrs ,配置服務端Channel的相關屬性;
  • 設定ChildOptions、ChildAttrs,配置每個新連線的Channel的相關屬性;
  • Config handler,配置服務端pipeline;
  • add ServerBootstrapAcceptor,新增聯結器,對accpet接受到的新連線進行處理,新增一個nio執行緒;

那麼接下來我們通過程式碼,對每一步設定進行一下分析:

首先是在SeverBootstrap的init()方法中對ChannelOptions、ChannelAttrs 的配置的關鍵程式碼

        final Map<ChannelOption<?>, Object> options = options0();//拿到你設定的option
        synchronized (options) {
            setChannelOptions(channel, options, logger);//設定NioServerSocketChannel相應的TCP引數,其實這一步就是把options設定到channel的config中
        }

        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());
            }
        }

然後是對ChildOptions、ChildAttrs配置的關鍵程式碼

        //可以看到兩個都是區域性變數,會在下面設定pipeline時用到
        final Entry<ChannelOption<?>, Object>[] currentChildOptions;
        final Entry<AttributeKey<?>, Object>[] currentChildAttrs;
        synchronized (childOptions) {
            currentChildOptions = childOptions.entrySet().toArray(newOptionArray(0));
        }
        synchronized (childAttrs) {
            currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(0));
        }

第三步對服務端Channel的handler進行配置

        p.addLast(new ChannelInitializer<Channel>() {
            @Override
            public void initChannel(final Channel ch) throws Exception {
                final ChannelPipeline pipeline = ch.pipeline();
                ChannelHandler handler = config.handler();//拿到我們自定義的hanler
                if (handler != null) {
                    pipeline.addLast(handler);
                }

                ch.eventLoop().execute(new Runnable() {
                    @Override
                    public void run() {
                        pipeline.addLast(new ServerBootstrapAcceptor(
                                ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
                    }
                });
            }
        });

第四步新增ServerBootstrapAcceptor聯結器,這個是netty向服務端Channel自定義新增的一個handler,用來處理新連線的新增與屬性配置,我們來看下關鍵程式碼

                ch.eventLoop().execute(new Runnable() {
                    @Override
                    public void run() {
                        //在這裡會把我們自定義的ChildGroup、ChildHandler、ChildOptions、ChildAttrs相關配置傳入到ServerBootstrapAcceptor建構函式中,並繫結到新的連線上
                        pipeline.addLast(new ServerBootstrapAcceptor(
                                ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
                    }
                });

三、註冊Selector

一個服務端的Channel建立完畢後,下一步就是要把它註冊到一個事件輪詢器Selector上,在initAndRegister()中我們把上面初始化的Channel進行註冊

ChannelFuture regFuture = config().group().register(channel);//註冊我們已經初始化過的Channel

而這個register具體實現是在AbstractChannel中的AbstractUnsafe抽象類中的

 /**
         * 1、先是一系列的判斷。
         * 2、判斷當前執行緒是否是給定的 eventLoop 執行緒。注意:這點很重要,Netty 執行緒模型的高效能取決於對於當前執行的Thread 的身份的確定。如果不在當前執行緒,那麼就需要很多同步措施(比如加鎖),上下文切換等耗費效能的操作。
         * 3、非同步(因為我們這裡直到現在還是 main 執行緒在執行,不屬於當前執行緒)的執行 register0 方法。
         */
        @Override
        public final void register(EventLoop eventLoop, final ChannelPromise promise) {
            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;
            }

            AbstractChannel.this.eventLoop = eventLoop;//繫結執行緒

            if (eventLoop.inEventLoop()) {
                register0(promise);//實際的註冊過程
            } else {
                try {
                    eventLoop.execute(new Runnable() {
                        @Override
                        public void run() {
                            register0(promise);
                        }
                    });
                } 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);
                }
            }
        }

 

首先我們對整個註冊的流程做一個梳理

 接下來我們進入register0()方法看下注冊過程的具體實現

        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();//jdk channel的底層註冊
                neverRegistered = false;
                registered = true;

                // 觸發繫結的handler事件
                // 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();

               
                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()) {
                    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();
                    }
                }
            } catch (Throwable t) {
                // Close the channel directly to avoid FD leak.
                closeForcibly();
                closeFuture.setClosed();
                safeSetFailure(promise, t);
            }
        }

AbstractNioChannel中doRegister()的具體實現就是把jdk底層的channel繫結到eventLoop的selecor上

    @Override
    protected void doRegister() throws Exception {
        boolean selected = false;
        for (;;) {
            try {
                //把channel註冊到eventLoop上的selector上
                selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);
                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;
                }
            }
        }
    }

到這裡netty就把服務端的channel註冊到了指定的selector上,下面就是服務埠的邦迪

三、埠繫結

首先我們梳理下netty中服務埠繫結的流程

我們來看下AbstarctUnsafe中bind()方法的具體實現

 @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);//底層jdk繫結埠
            } catch (Throwable t) {
                safeSetFailure(promise, t);
                closeIfClosed();
                return;
            }

            if (!wasActive && isActive()) {
                invokeLater(new Runnable() {
                    @Override
                    public void run() {
                        pipeline.fireChannelActive();//觸發ChannelActive事件
                    }
                });
            }

            safeSetSuccess(promise);
        }

在doBind(localAddress)中netty實現了jdk底層埠的繫結

    @Override
    protected void doBind(SocketAddress localAddress) throws Exception {
        if (PlatformDependent.javaVersion() >= 7) {
            javaChannel().bind(localAddress, config.getBacklog());
        } else {
            javaChannel().socket().bind(localAddress, config.getBacklog());
        }
    }

在 pipeline.fireChannelActive()中會觸發pipeline中的channelActive()方法

        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            ctx.fireChannelActive();

            readIfIsAutoRead();
        }

在channelActive中首先會把ChannelActive事件往下傳播,然後呼叫readIfIsAutoRead()方法出觸發channel的read事件,而它最終呼叫AbstractNioChannel中的doBeginRead()方法

    @Override
    protected void doBeginRead() throws Exception {
        // Channel.read() or ChannelHandlerContext.read() was called
        final SelectionKey selectionKey = this.selectionKey;
        if (!selectionKey.isValid()) {
            return;
        }

        readPending = true;

        final int interestOps = selectionKey.interestOps();
        if ((interestOps & readInterestOp) == 0) {
            selectionKey.interestOps(interestOps | readInterestOp);//readInterestOp為  SelectionKey.OP_ACCEPT
        }
    }

 在doBeginRead()方法,netty會把accept事件註冊到Selector上。

到此我們對netty服務端的啟動流程有了一個大致的瞭解,整體可以概括為下面四步:

1、channelFactory.newChannel(),其實就是建立jdk底層channel,並初始化id、piepline等屬性;

2、init(channel),新增option、attr等屬性,並新增ServerBootstrapAcceptor聯結器;

3、config().group().register(channel),把jdk底層的channel註冊到eventLoop上的selector上;

4、doBind0(regFuture, channel, localAddress, promise),完成服務端埠的監聽,並把accept事件註冊到selector上;

以上就是對netty服務端啟動流程進行的一個簡單分析,有很多細節沒有關注與深入,其中如有不足與不正確的地方還望指出與海涵。