Netty原始碼學習系列之1-NioEventLoopGroup的初始化

前言

    NioEventLoopGroup是netty對Reactor執行緒組這個抽象概念的具體實現，其內部維護了一個EventExecutor陣列，而NioEventLoop就是EventExecutor的實現（看名字也可發現，一個是NioEventLoopGroup，一個是NioEventLoop，前者是集合，後者是集合中的元素）。一個NioEventLoop中執行著唯一的一個執行緒即Reactor執行緒，這個執行緒一直執行NioEventLoop的run方法。這個run方法就是netty的核心方法，其重要性可以類比於Spring中的refresh方法。

    下面是從百度上隨便找的一篇netty文章的執行緒模型圖（詳見文章https://www.cnblogs.com/luoxn28/p/11875340.html），此處引用是為方便在頭腦中產生一個整體印象，結合圖下面的程式碼進行各個概念的歸位。圖中綠色的Reactor Thread就是上文說的NioEventLoopGroup，對應下面程式碼中的boss變數，負責處理客戶端的連線事件，它其實也是一個池（因為內部維護的是一個陣列）；藍色的Reactor Thread Pool也是NioEventLoopGroup，對應下面程式碼中的worker變數，負責處理客戶端的讀寫事件。

 

 

     注：上圖是Reactor多執行緒模型，而下面的程式碼示例是主從多執行緒模型，區別是隻要將程式碼boss中的引數2改成1，示例程式碼就成了多執行緒模型，細細品味一下。

public class NettyDemo1 {
    // netty服務端的一般性寫法
    public static void main(String[] args) {
        EventLoopGroup boss = new NioEventLoopGroup(2);
        EventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(boss, worker).channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 100)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            pipeline.addLast(new StringDecoder());
                            pipeline.addLast(new StringEncoder());
                            pipeline.addLast(new NettyServerHandler());
                        }
                    });
            ChannelFuture channelFuture = bootstrap.bind(90);
            channelFuture.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }
}

    以上部分是博主對netty的一個概括性總結，以將概念和其實現連線起來，方便建立一個初始的總體認識，下面進入EventLoopGroup的初始化。

一、EventLoopGroup初始化

1、NioEventLoopGroup構造器

    順著有參和無參的構造方法進去，發現無參的構造器將執行緒數賦值0繼續調了有參的構造器，而有參的構造器將執行緒池executor引數賦值null繼續調過載構造器

public NioEventLoopGroup() {
        this(0);
    }

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

public NioEventLoopGroup(int nThreads, Executor executor) {
        this(nThreads, executor, SelectorProvider.provider());
    }

    因為博主是在膝上型電腦除錯的，故此時的selectorProvider是WindowsSelectorProvider，然後又加了一個引數DefaultSelectStrategyFactory單例物件：

public NioEventLoopGroup(
            int nThreads, Executor executor, final SelectorProvider selectorProvider) {
        this(nThreads, executor, selectorProvider, DefaultSelectStrategyFactory.INSTANCE);
    }

    然後調父類的構造器，在末尾增加一個引數RejectedExecutionHandler單例物件：

public NioEventLoopGroup(int nThreads, Executor executor, final SelectorProvider selectorProvider,
                             final SelectStrategyFactory selectStrategyFactory) {
        super(nThreads, executor, selectorProvider, selectStrategyFactory, RejectedExecutionHandlers.reject());
    }

 

2、MultithreadEventLoopGroup構造器

    在該構造器中，對執行緒數引數進行了處理，如果是0（對應上面NioEventLoopGroup的無參構造器），則將執行緒數設定為預設值，預設值取的是CPU核數*2，8核處理器對應16個執行緒；如果不是0，則以指定的執行緒數為準。同時，將executor後面的引數變為陣列的形式，對應上面可以知道args中有三個元素：WindowsSelectorProvider、DefaultSelectStrategyFactory、RejectedExecutionHandler。

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

 

3、MultithreadEventExecutorGroup構造器

    此構造器又在args陣列前面加了一個單例物件DefaultEventExecutorChooserFactory，用於從NioEventLoopGroup的陣列中選取一個NioEventLoop。

protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
        this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
    }

    下面才是最終的核心構造器方法，結合註釋應該比較好理解。其中最重要的是第3步和第4步，下面著重講解這兩步。

protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                            EventExecutorChooserFactory chooserFactory, Object... args) {
        // 1.對執行緒數進行校驗
        if (nThreads <= 0) {
            throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
        }
        // 2.給執行緒池引數賦值，從前面追蹤可知，若未賦值，executor一直是null，後續用於建立NioEventLoop中的啟動執行緒，所以這玩意就是一個執行緒工廠
        if (executor == null) {
            executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
        }
        // 3.給children迴圈賦值，newChild方法是重點，後續會講解 ***
        children = new EventExecutor[nThreads];
        for (int i = 0; i < nThreads; i ++) {
            boolean success = false;
            try {
                children[i] = newChild(executor, 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 {
                // 省略掉未建立成功後的資源釋放處理
            }
        }
        // 4.完成chooser選擇器的賦值，此處是netty一個小的優化點，後續會講解 **
        chooser = chooserFactory.newChooser(children);
        // 5.給陣列中每一個成員設定監聽器處理
        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);
        }
        // 6.設定一個只讀的set集合
        Set<EventExecutor> childrenSet = new LinkedHashSet<EventExecutor>(children.length);
        Collections.addAll(childrenSet, children);
        readonlyChildren = Collections.unmodifiableSet(childrenSet);
    }

 

3.1)、第4步chooser的賦值

    由上面構造器呼叫過程可知，chooserFactory對應DefaultEventExecutorChooserFactory物件，該物件的newChooser方法如下：

public EventExecutorChooser newChooser(EventExecutor[] executors) {
        if (isPowerOfTwo(executors.length)) {
            return new PowerOfTwoEventExecutorChooser(executors);
        } else {
            return new GenericEventExecutorChooser(executors);
        }
    }

    邏輯比較簡單，判斷陣列的長度是不是2的N次冪，如果是，返回PowerOfTwoEventExecutorChooser物件，如果不是則返回GenericEventExecutorChooser物件。這二者有什麼區別，netty設計者為什麼要這麼做呢？如果對HashMap的實現原理有深入瞭解的園友應該不難想到，如果一個數X是2的N次冪，那麼用任意一個數Y對X取模可以用Y&(X-1)來高效的完成，這樣做比直接%取模快了好幾倍，這也是HashMap用2次冪作為陣列長度的主要原因。這裡是同樣的道理，如下程式碼所示，這兩個chooser類都很簡單，內部維護了一個原子遞增物件，每次呼叫next方法都加1，然後用這個數與陣列長度取模，得到要對應下標位置的元素。而如果陣列長度剛好是2次冪，用PowerOfTwoEventExecutorChooser就會提高效率，如果不是那也沒辦法，走%取模就是了。netty這種對效率提升的處理，是否在平時的CRUD中也能套用一下呢？

private static final class PowerOfTwoEventExecutorChooser implements EventExecutorChooser {
        private final AtomicInteger idx = new AtomicInteger();
        private final EventExecutor[] executors;

        PowerOfTwoEventExecutorChooser(EventExecutor[] executors) {
            this.executors = executors;
        }

        @Override
        public EventExecutor next() {
            return executors[idx.getAndIncrement() & executors.length - 1];
        }
    }

    private static final class GenericEventExecutorChooser implements EventExecutorChooser {
        private final AtomicInteger idx = new AtomicInteger();
        private final EventExecutor[] executors;

        GenericEventExecutorChooser(EventExecutor[] executors) {
            this.executors = executors;
        }

        @Override
        public EventExecutor next() {
            return executors[Math.abs(idx.getAndIncrement() % executors.length)];
        }
    }

 

3.2)、第3步newChild方法的邏輯

    該方法的實現在NioEventLoopGroup中，由於args長度為3，所以queueFactory為null（暫時未發現哪裡的實現args引數長度會是4，或許只是為後續擴充套件用，如果園友對args長度為4的場景有了解的還請留言指教）。然後呼叫了NioEventLoop的構造器，下面進入NioEventLoop的初始化。

protected EventLoop newChild(Executor executor, Object... args) throws Exception {
        EventLoopTaskQueueFactory queueFactory = args.length == 4 ? (EventLoopTaskQueueFactory) args[3] : null;
        return new NioEventLoop(this, executor, (SelectorProvider) args[0],
            ((SelectStrategyFactory) args[1]).newSelectStrategy(), (RejectedExecutionHandler) args[2], queueFactory);
    }

    執行完上述初始化方法後NioEventLoopGroup的快照圖如下，最重要的就兩個屬性：child和chooser。

 

 

 

二、NioEventLoop的初始化

1、NioEventLoop的構造器

    到這裡，有必要將此構造器的入參再梳理一遍。parent即上面的NioEventLoopGroup物件，executor是在MultithreadEventExecutorGroup中初始化的ThreadPerTaskExecutor，selectorProvider是WindowsSelectorProvider，strategy是DefaultSelectStrategyFactory，rejectedExecutionHandler是RejectedExecutionHandler，queueFactory是null。

NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider,
                 SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler,
                 EventLoopTaskQueueFactory queueFactory) {
        super(parent, executor, false, newTaskQueue(queueFactory), newTaskQueue(queueFactory),
                rejectedExecutionHandler);
        if (selectorProvider == null) {
            throw new NullPointerException("selectorProvider");
        }
        if (strategy == null) {
            throw new NullPointerException("selectStrategy");
        }
        provider = selectorProvider;
        final SelectorTuple selectorTuple = openSelector();
        selector = selectorTuple.selector;// netty封裝的selector
        unwrappedSelector = selectorTuple.unwrappedSelector;// java NIO原生的selector
        selectStrategy = strategy;
    }

    可以看到只是做了一些賦值，其中newTaskQueue方法建立的是MpscUnboundedArrayQueue佇列（多生產單消費無界佇列，mpsc是multi provider single consumer的首字母縮寫，即多個生產一個消費），繼續追查父類構造方法。

 

2、SingleThreadEventLoop構造器

    呼叫父類構造器，給tailTasks賦值。

protected SingleThreadEventLoop(EventLoopGroup parent, Executor executor,
                                    boolean addTaskWakesUp, Queue<Runnable> taskQueue, Queue<Runnable> tailTaskQueue,
                                    RejectedExecutionHandler rejectedExecutionHandler) {
        super(parent, executor, addTaskWakesUp, taskQueue, rejectedExecutionHandler);
        tailTasks = ObjectUtil.checkNotNull(tailTaskQueue, "tailTaskQueue");
    }

 

3、SingleThreadEventExecutor構造器

    在該構造方法中完成了剩餘變數的賦值，其中有兩個變數很重要：executor和taskQueue。前者負責建立Reactor執行緒，後者是實現序列無鎖化的任務佇列。

protected SingleThreadEventExecutor(EventExecutorGroup parent, Executor executor,
                                        boolean addTaskWakesUp, Queue<Runnable> taskQueue,
                                        RejectedExecutionHandler rejectedHandler) {
        super(parent);
        this.addTaskWakesUp = addTaskWakesUp;
        this.maxPendingTasks = DEFAULT_MAX_PENDING_EXECUTOR_TASKS;
        this.executor = ThreadExecutorMap.apply(executor, this);
        this.taskQueue = ObjectUtil.checkNotNull(taskQueue, "taskQueue");
        rejectedExecutionHandler = ObjectUtil.checkNotNull(rejectedHandler, "rejectedHandler");
    }

    NioEventLoopGroup的物件引用最終記錄在了AbstractEventExecutor中：

protected AbstractEventExecutor(EventExecutorGroup parent) {
        this.parent = parent;
    }

    NioeventLoop初始化完成之後的物件快照如下，左邊是子類，右邊是父類：

 

 

小結

    本文詳細講述了netty中Reactor執行緒組概念模型的實現類 -- NioEventLoopGroup的例項化過程。NioEventLoopGroup和其內部陣列元素NioEventLoop是netty通訊框架的基石，相信本文的內容對初學netty的園友有一點幫助。

    下篇將研究ServerBootstrap的初始化過程，敬請期待。