深入淺出Netty：服務啟動

本系列：

本節主要分析server的啟動過程。

Netty是基於Nio實現的，所以也離不開selector、serverSocketChannel、socketChannel和selectKey等，只不過Netty把這些實現都封裝在了底層。

從示例可以看出，一切從ServerBootstrap開始。

ServerBootstrap例項中需要兩個NioEventLoopGroup例項，分別為boss和work，有不同的分工：
1、 boss負責請求的accept操作。
2、 work負責請求的read、write和處理操作。

NioEventLoopGroup

NioEventLoopGroup主要負責管理eventLoop的生命週期，eventLoop數量預設為處理器個數的兩倍。

NioEventLoopGroup

繼承關係如下：

NioEventLoopGroup

NioEventLoopGroup構造方法：

public NioEventLoopGroup() {  
    this(0);  
}  

public NioEventLoopGroup(int nThreads) {  
    this(nThreads, null); 
}  

public NioEventLoopGroup(int nThreads, ThreadFactory threadFactory) {  
    this(nThreads, threadFactory, SelectorProvider.provider());  
}  

public NioEventLoopGroup(  
            int nThreads, ThreadFactory threadFactory, final SelectorProvider selectorProvider) {  
    super(nThreads, threadFactory, selectorProvider);  
}

12345678910111213141516

publicNioEventLoopGroup(){this(0);}publicNioEventLoopGroup(intnThreads){this(nThreads,null);}publicNioEventLoopGroup(intnThreads,ThreadFactory threadFactory){this(nThreads,threadFactory,SelectorProvider.provider());}publicNioEventLoopGroup

(intnThreads,ThreadFactory threadFactory,finalSelectorProvider selectorProvider){super(nThreads,threadFactory,selectorProvider);}

MultithreadEventLoopGroup構造方法：

protected MultithreadEventLoopGroup(int nThreads, ThreadFactory threadFactory, Object... args) {  
    super(nThreads == 0? DEFAULT_EVENT_LOOP_THREADS : nThreads, threadFactory, args);  
}

123	protectedMultithreadEventLoopGroup(intnThreads,ThreadFactory threadFactory,Object...args){super(nThreads==0?DEFAULT_EVENT_LOOP_THREADS:nThreads,threadFactory,args);}

其中 DEFAULT_EVENT_LOOP_THREADS 為處理器數量的兩倍。

MultithreadEventExecutorGroup是核心，管理eventLoop的生命週期，先看看其中幾個變數。
1、children：EventExecutor陣列，儲存eventLoop。
2、chooser：從children中選取一個eventLoop的策略。

構造方法：

protected MultithreadEventExecutorGroup(int nThreads, ThreadFactory threadFactory, Object... args) {
    if (nThreads <= 0) {
        throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
    }

    if (threadFactory == null) {
        threadFactory = newDefaultThreadFactory();
    }

    children = new SingleThreadEventExecutor[nThreads];
    if (isPowerOfTwo(children.length)) {
        chooser = new PowerOfTwoEventExecutorChooser();
    } else {
        chooser = new GenericEventExecutorChooser();
    }

    for (int i = 0; i < nThreads; i ++) {
        boolean success = false;
        try {
            children[i] = newChild(threadFactory, args);
            success = true;
        } catch (Exception e) {
            // TODO: Think about if this is a good exception type
            throw new IllegalStateException("failed to create a child event loop", e);
        } finally {
            if (!success) {
                for (int j = 0; j < i; j ++) {
                    children[j].shutdownGracefully();
                }

                for (int j = 0; j < i; j ++) {
                    EventExecutor e = children[j];
                    try {
                        while (!e.isTerminated()) {
                            e.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
                        }
                    } catch (InterruptedException interrupted) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            }
        }
    }

    final FutureListener<Object> terminationListener = new FutureListener<Object>() {
        @Override
        public void operationComplete(Future<Object> future) throws Exception {
            if (terminatedChildren.incrementAndGet() == children.length) {
                terminationFuture.setSuccess(null);
            }
        }
    };

    for (EventExecutor e: children) {
        e.terminationFuture().addListener(terminationListener);
    }
}

 protected EventExecutor newChild(  
            ThreadFactory threadFactory, Object... args) throws Exception {  
      return new NioEventLoop(this, threadFactory, (SelectorProvider) args[0]);  
}

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263

protectedMultithreadEventExecutorGroup(intnThreads,ThreadFactory threadFactory,Object...args){if(nThreads<=0){thrownewIllegalArgumentException(String.format("nThreads: %d (expected: > 0)",nThreads));}if(threadFactory==null){threadFactory=newDefaultThreadFactory();}children=newSingleThreadEventExecutor[nThreads];if(isPowerOfTwo(children.length)){chooser=newPowerOfTwoEventExecutorChooser();}else{chooser=newGenericEventExecutorChooser();}for(inti=0;i<nThreads;i++){booleansuccess=false;try{children[i]=newChild(threadFactory,args);success=true;}catch(Exceptione){// TODO: Think about if this is a good exception typethrownewIllegalStateException("failed to create a child event loop",e);}finally{if(!success){for(intj=0;j<i;j++){children[j].shutdownGracefully();}for(intj=0;j<i;j++){EventExecutore=children[j];try{while(!e.isTerminated()){e.awaitTermination(Integer.MAX_VALUE,TimeUnit.SECONDS);}}catch(InterruptedException interrupted){Thread.currentThread().interrupt();break;}}}}}finalFutureListener<Object>terminationListener=newFutureListener<Object>(){@OverridepublicvoidoperationComplete(Future<Object>future)throwsException{if(terminatedChildren.incrementAndGet()==children.length){terminationFuture.setSuccess(null);}}};for(EventExecutore:children){e.terminationFuture().addListener(terminationListener);}}protectedEventExecutor newChild(ThreadFactory threadFactory,Object...args)throwsException{returnnewNioEventLoop(this,threadFactory,(SelectorProvider)args[0]);}

1、根據陣列的大小，採用不同策略初始化chooser。
如果大小為2的冪次方，則採用PowerOfTwoEventExecutorChooser；否則使用GenericEventExecutorChooser。
判斷一個數是否是2的冪次方的方法，覺得很贊。

private static boolean isPowerOfTwo(int val) {
      return (val & -val) == val;
}

123	privatestaticbooleanisPowerOfTwo(intval){return(val&-val)==val;}

2、newChild方法過載，初始化EventExecutor時，實際執行的是NioEventLoopGroup中的newChild方法，所以，children元素的實際型別為NioEventLoop。

接下去看看NioEventLoop類。

NioEventLoop

每個eventLoop會維護一個selector和taskQueue，負責處理客戶端請求和內部任務，如ServerSocketChannel註冊和ServerSocket繫結等。

NioEventLoop

繼承關係如下：

NioEventLoop

構造方法：

 NioEventLoop(NioEventLoopGroup parent, ThreadFactory threadFactory, SelectorProvider selectorProvider) {  
      super(parent, threadFactory, false);  
      if (selectorProvider == null) {  
          throw new NullPointerException("selectorProvider");  
      }  
      provider = selectorProvider;  
      selector = openSelector();  
}

12345678

NioEventLoop(NioEventLoopGroup parent,ThreadFactory threadFactory,SelectorProvider selectorProvider){super(parent,threadFactory,false);if(selectorProvider==null){thrownewNullPointerException("selectorProvider");}provider=selectorProvider;selector=openSelector();}

當看到 selector = openSelector() 時，有沒有覺得親切了許多，這裡先不管 selector，看看SingleThreadEventLoop類。

SingleThreadEventLoop 構造方法：

protected SingleThreadEventLoop(EventLoopGroup parent, ThreadFactory threadFactory, boolean addTaskWakesUp) {
    super(parent, threadFactory, addTaskWakesUp);
}

123	protectedSingleThreadEventLoop(EventLoopGroup parent,ThreadFactory threadFactory,booleanaddTaskWakesUp){super(parent,threadFactory,addTaskWakesUp);}

啥事都沒做…

SingleThreadEventExecutor
從命名上可以看出，這是一個只有一個執行緒的執行緒池，先看看其中的幾個變數：
1、state：執行緒池當前的狀態
2、taskQueue：存放任務的佇列
3、thread：執行緒池維護的唯一執行緒
4、scheduledTaskQueue：定義在其父類AbstractScheduledEventExecutor中，用以儲存延遲執行的任務。
…
構造方法：

protected SingleThreadEventExecutor(EventExecutorGroup parent, ThreadFactory threadFactory, boolean addTaskWakesUp) {
    if (threadFactory == null) {
        throw new NullPointerException("threadFactory");
    }
    this.parent = parent;
    this.addTaskWakesUp = addTaskWakesUp;

    thread = threadFactory.newThread(new Runnable() {
        @Override
        public void run() {
            boolean success = false;
            updateLastExecutionTime();
            try {
                SingleThreadEventExecutor.this.run();
                success = true;
            } catch (Throwable t) {
                logger.warn("Unexpected exception from an event executor: ", t);
            } finally {
                for (;;) {
                    int oldState = STATE_UPDATER.get(SingleThreadEventExecutor.this);
                    if (oldState >= ST_SHUTTING_DOWN || STATE_UPDATER.compareAndSet(
                            SingleThreadEventExecutor.this, oldState, ST_SHUTTING_DOWN)) {
                        break;
                    }
                }
                // Check if confirmShutdown() was called at the end of the loop.
                if (success && gracefulShutdownStartTime == 0) {
                    logger.error(
                            "Buggy " + EventExecutor.class.getSimpleName() + " implementation; " +
                            SingleThreadEventExecutor.class.getSimpleName() + ".confirmShutdown() must be called " +
                            "before run() implementation terminates.");
                }

                try {
                    // Run all remaining tasks and shutdown hooks.
                    for (;;) {
                        if (confirmShutdown()) {
                            break;
                        }
                    }
                } finally {
                    try {
                        cleanup();
                    } finally {
                        STATE_UPDATER.set(SingleThreadEventExecutor.this, ST_TERMINATED);
                        threadLock.release();
                        if (!taskQueue.isEmpty()) {
                            logger.warn(
                                    "An event executor terminated with " +
                                    "non-empty task queue (" + taskQueue.size() + ')');
                        }

                        terminationFuture.setSuccess(null);
                    }
                }
            }
        }
    });
    threadProperties = new DefaultThreadProperties(thread);
    taskQueue = newTaskQueue();
}

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061

protectedSingleThreadEventExecutor(EventExecutorGroup parent,ThreadFactory threadFactory,booleanaddTaskWakesUp){if(threadFactory==null){thrownewNullPointerException("threadFactory");}this.parent=parent;this.addTaskWakesUp=addTaskWakesUp;thread=threadFactory.newThread(newRunnable(){@Overridepublicvoidrun(){booleansuccess=false;updateLastExecutionTime();try{SingleThreadEventExecutor.this.run();success=true;}catch(Throwablet){logger.warn("Unexpected exception from an event executor: ",t);}finally{for(;;){intoldState=STATE_UPDATER.get(SingleThreadEventExecutor.this);if(oldState>=ST_SHUTTING_DOWN||STATE_UPDATER.compareAndSet(SingleThreadEventExecutor.this,oldState,ST_SHUTTING_DOWN)){break;}}// Check if confirmShutdown() was called at the end of the loop.if(success&&gracefulShutdownStartTime==0){logger.error("Buggy "+EventExecutor.class.getSimpleName()+" implementation; "+SingleThreadEventExecutor.class.getSimpleName()+

深入淺出Netty：服務啟動

NioEventLoopGroup

NioEventLoop

深入淺出Netty：服務啟動

mysql配置中吃的虧：服務啟動失敗，服務沒有報告任何錯誤

深入淺出Netty：write

深入淺出Netty：NioEventLoop

深入淺出Netty：ChannelPipeline

深入淺出Netty：read

深入淺出Netty：accept

Flask原始碼分析一：服務啟動

Netty原始碼分析：服務端啟動全過程(篇幅很長)

Netty入門一：服務端應用搭建 & 啟動過程原始碼分析

windows版redis報錯：本地計算機上的Redis服務啟動後停止

Oracle11g啟動Server服務報錯：錯誤1053：服務沒有及時響應或控制請求

ZABBIX：內存溢出導致zabbix-server/zabbix_server 服務啟動不起來

Netty（五）：ServerBootstrap啟動流程

IOS推送http2使用netty服務啟動異常

eShopOnContainers 看微服務 ②：配置啟動

java複習筆記2--SpringCloud系列一：微服務啟動原理探索

java複習筆記3--SpringCloud系列一：微服務啟動原理探之beanFactory載入

java複習筆記3--SpringCloud系列一：微服務啟動原理探索之beanFactory載入

啟動 MySQL：服務無法啟動，服務沒有報告任何錯誤 - 已解決

深入淺出Netty：服務啟動

NioEventLoopGroup

NioEventLoop

相關推薦