完美世界,完美世界有声小说

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案

聊聊Netty那些事兒之Reactor在Netty中的實現(xiàn)(創(chuàng)建篇)

本系列Netty源碼解析文章基于 4.1.56.Final版本

10多年的隨州網(wǎng)站建設(shè)經(jīng)驗，針對設(shè)計、前端、開發(fā)、售后、文案、推廣等六對一服務，響應快，48小時及時工作處理。營銷型網(wǎng)站建設(shè)的優(yōu)勢是能夠根據(jù)用戶設(shè)備顯示端的尺寸不同，自動調(diào)整隨州建站的顯示方式，使網(wǎng)站能夠適用不同顯示終端，在瀏覽器中調(diào)整網(wǎng)站的寬度，無論在任何一種瀏覽器上瀏覽網(wǎng)站，都能展現(xiàn)優(yōu)雅布局與設(shè)計，從而大程度地提升瀏覽體驗。創(chuàng)新互聯(lián)從事“隨州網(wǎng)站設(shè)計”,“隨州網(wǎng)站推廣”以來，每個客戶項目都認真落實執(zhí)行。

在上篇文章??《聊聊Netty那些事兒之從內(nèi)核角度看IO模型》??中我們花了大量的篇幅來從內(nèi)核角度詳細講述了五種IO模型的演進過程以及ReactorIO線程模型的底層基石IO多路復用技術(shù)在內(nèi)核中的實現(xiàn)原理。

最后我們引出了netty中使用的主從Reactor IO線程模型。

通過上篇文章的介紹，我們已經(jīng)清楚了在IO調(diào)用的過程中內(nèi)核幫我們搞了哪些事情，那么俗話說的好內(nèi)核領(lǐng)進門，修行在netty，netty在用戶空間又幫我們搞了哪些事情?

那么從本文開始，筆者將從源碼角度來帶大家看下上圖中的Reactor IO線程模型在Netty中是如何實現(xiàn)的。

本文作為Reactor在Netty中實現(xiàn)系列文章中的開篇文章，筆者先來為大家介紹Reactor的骨架是如何創(chuàng)建出來的。

在上篇文章中我們提到Netty采用的是主從Reactor多線程的模型，但是它在實現(xiàn)上又與Doug Lea在Scalable IO in Java論文中提到的經(jīng)典主從Reactor多線程模型有所差異。

Netty中的Reactor是以Group的形式出現(xiàn)的，主從Reactor在Netty中就是主從Reactor組，每個Reactor Group中會有多個Reactor用來執(zhí)行具體的IO任務。當然在netty中Reactor不只用來執(zhí)行IO任務，這個我們后面再說。

Main Reactor Group中的Reactor數(shù)量取決于服務端要監(jiān)聽的端口個數(shù)，通常我們的服務端程序只會監(jiān)聽一個端口，所以Main Reactor Group只會有一個Main Reactor線程來處理最重要的事情：綁定端口地址，接收客戶端連接，為客戶端創(chuàng)建對應的SocketChannel，將客戶端SocketChannel分配給一個固定的Sub Reactor。也就是上篇文章筆者為大家舉的例子，飯店最重要的工作就是先把客人迎接進來。“我家大門常打開，開放懷抱等你，擁抱過就有了默契你會愛上這里......”

Sub Reactor Group里有多個Reactor線程，Reactor線程的個數(shù)可以通過系統(tǒng)參數(shù)-D io.netty.eventLoopThreads指定。默認的Reactor的個數(shù)為CPU核數(shù) * 2。Sub Reactor線程主要用來輪詢客戶端SocketChannel上的IO就緒事件，處理IO就緒事件，執(zhí)行異步任務。Sub Reactor Group做的事情就是上篇飯店例子中服務員的工作，客人進來了要為客人分配座位，端茶送水，做菜上菜?！安还苓h近都是客人，請不用客氣，相約好了在一起，我們歡迎您......”

一個客戶端SocketChannel只能分配給一個固定的Sub Reactor。一個Sub Reactor負責處理多個客戶端SocketChannel，這樣可以將服務端承載的全量客戶端連接分攤到多個Sub Reactor中處理，同時也能保證客戶端SocketChannel上的IO處理的線程安全性。

由于文章篇幅的關(guān)系，作為Reactor在netty中實現(xiàn)的第一篇我們主要來介紹主從Reactor Group的創(chuàng)建流程，骨架脈絡先搭好。

下面我們來看一段Netty服務端代碼的編寫模板，從代碼模板的流程中我們來解析下主從Reactor的創(chuàng)建流程以及在這個過程中所涉及到的Netty核心類。

Netty服務端代碼模板

/**
 * Echoes back any received data from a client.
 */
public final class EchoServer {
    static final int PORT = Integer.parseInt(System.getProperty("port", "8007"));
    public static void main(String[] args) throws Exception {
        // Configure the server.
        //創(chuàng)建主從Reactor線程組
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        final EchoServerHandler serverHandler = new EchoServerHandler();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)//配置主從Reactor
             .channel(NioServerSocketChannel.class)//配置主Reactor中的channel類型
             .option(ChannelOption.SO_BACKLOG, 100)//設(shè)置主Reactor中channel的option選項
             .handler(new LoggingHandler(LogLevel.INFO))//設(shè)置主Reactor中Channel->pipline->handler
             .childHandler(new ChannelInitializer() {//設(shè)置從Reactor中注冊channel的pipeline
                 @Override
                 public void initChannel(SocketChannel ch) throws Exception {
                     ChannelPipeline p = ch.pipeline();
                     //p.addLast(new LoggingHandler(LogLevel.INFO));
                     p.addLast(serverHandler);
                 }
             });
            // Start the server. 綁定端口啟動服務，開始監(jiān)聽accept事件
            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();
        }
    }
}

首先我們要創(chuàng)建Netty最核心的部分 -> 創(chuàng)建主從Reactor Group，在Netty中EventLoopGroup就是Reactor Group的實現(xiàn)類。對應的EventLoop就是Reactor的實現(xiàn)類。

  //創(chuàng)建主從Reactor線程組
  EventLoopGroup bossGroup = new NioEventLoopGroup(1);
  EventLoopGroup workerGroup = new NioEventLoopGroup();

創(chuàng)建用于IO處理的ChannelHandler，實現(xiàn)相應IO事件的回調(diào)函數(shù)，編寫對應的IO處理邏輯。注意這里只是簡單示例哈，詳細的IO事件處理，筆者會單獨開一篇文章專門講述。

final EchoServerHandler serverHandler = new EchoServerHandler();
/**
 * Handler implementation for the echo server.
 */
@Sharable
public class EchoServerHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ................省略IO處理邏輯................
        ctx.write(msg);
    }
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
        
        ctx.flush();
    }
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        // Close the connection when an exception is raised.
        cause.printStackTrace();
        ctx.close();
    }
}

創(chuàng)建ServerBootstrapNetty服務端啟動類，并在啟動類中配置啟動Netty服務端所需要的一些必備信息。

在上篇文章介紹Socket內(nèi)核結(jié)構(gòu)小節(jié)中我們提到，在編寫服務端網(wǎng)絡程序時，我們首先要創(chuàng)建一個Socket用于listen和bind端口地址，我們把這個叫做監(jiān)聽Socket,這里對應的就是NioServerSocketChannel.class。當客戶端連接完成三次握手，系統(tǒng)調(diào)用accept函數(shù)會基于監(jiān)聽Socket創(chuàng)建出來一個新的Socket專門用于與客戶端之間的網(wǎng)絡通信我們稱為客戶端連接Socket,這里對應的就是NioSocketChannel.class。

netty有兩種Channel類型：一種是服務端用于監(jiān)聽綁定端口地址的NioServerSocketChannel,一種是用于客戶端通信的NioSocketChannel。每種Channel類型實例都會對應一個PipeLine用于編排對應channel實例上的IO事件處理邏輯。PipeLine中組織的就是ChannelHandler用于編寫特定的IO處理邏輯。

注意：serverBootstrap.handler設(shè)置的是服務端NioServerSocketChannel PipeLine中的ChannelHandler。

ServerBootstrap啟動類方法帶有child前綴的均是設(shè)置客戶端NioSocketChannel屬性的。
ChannelInitializer是用于當SocketChannel成功注冊到綁定的Reactor上后，用于初始化該SocketChannel的Pipeline。它的initChannel方法會在注冊成功后執(zhí)行。這里只是捎帶提一下，讓大家有個初步印象，后面我會專門介紹。
serverBootstrap.childHandler(ChannelHandler childHandler)用于設(shè)置客戶端NioSocketChannel中對應Pipieline中的ChannelHandler。我們通常配置的編碼解碼器就是在這里。
serverBootstrap.option(ChannelOption.SO_BACKLOG, 100)設(shè)置服務端ServerSocketChannel中的SocketOption。關(guān)于SocketOption的選項我們后邊的文章再聊，本文主要聚焦在Netty Main Reactor Group的創(chuàng)建及工作流程。
serverBootstrap.handler(....)設(shè)置服務端NioServerSocketChannel中對應Pipieline中的ChannelHandler。
通過serverBootstrap.group(bossGroup, workerGroup)為Netty服務端配置主從Reactor Group實例。
通過serverBootstrap.channel(NioServerSocketChannel.class)配置Netty服務端的ServerSocketChannel用于綁定端口地址以及創(chuàng)建客戶端SocketChannel。Netty中的NioServerSocketChannel.class就是對JDK NIO中ServerSocketChannel的封裝。而用于表示客戶端連接的NioSocketChannel是對JDK NIO SocketChannel封裝。

ChannelFuture f = serverBootstrap.bind(PORT).sync()這一步會是下篇文章要重點分析的主題Main Reactor Group的啟動，綁定端口地址，開始監(jiān)聽客戶端連接事件(OP_ACCEPT)。本文我們只關(guān)注創(chuàng)建流程。

f.channel().closeFuture().sync()等待服務端NioServerSocketChannel關(guān)閉。Netty服務端到這里正式啟動，并準備好接受客戶端連接的準備。

shutdownGracefully優(yōu)雅關(guān)閉主從Reactor線程組里的所有Reactor線程。

Netty對IO模型的支持

在上篇文章中我們介紹了五種IO模型，Netty中支持BIO,NIO,AIO以及多種操作系統(tǒng)下的IO多路復用技術(shù)實現(xiàn)。

在Netty中切換這幾種IO模型也是非常的方便，下面我們來看下Netty如何對這幾種IO模型進行支持的。

首先我們介紹下幾個與IO模型相關(guān)的重要接口：

EventLoop

EventLoop就是Netty中的Reactor，可以說它就是Netty的引擎，負責Channel上IO就緒事件的監(jiān)聽，IO就緒事件的處理，異步任務的執(zhí)行驅(qū)動著整個Netty的運轉(zhuǎn)。

不同IO模型下，EventLoop有著不同的實現(xiàn)，我們只需要切換不同的實現(xiàn)類就可以完成對NettyIO模型的切換。

在NIO模型下Netty會自動根據(jù)操作系統(tǒng)以及版本的不同選擇對應的IO多路復用技術(shù)實現(xiàn)。比如Linux 2.6版本以上用的是Epoll，2.6版本以下用的是Poll，Mac下采用的是Kqueue。

其中Linux kernel 在5.1版本引入的異步IO庫io_uring正在netty中孵化。

EventLoopGroup

Netty中的Reactor是以Group的形式出現(xiàn)的，EventLoopGroup正是Reactor組的接口定義，負責管理Reactor，Netty中的Channel就是通過EventLoopGroup注冊到具體的Reactor上的。

Netty的IO線程模型是主從Reactor多線程模型，主從Reactor線程組在Netty源碼中對應的其實就是兩個EventLoopGroup實例。

不同的IO模型也有對應的實現(xiàn)：

ServerSocketChannel

用于Netty服務端使用的ServerSocketChannel，對應于上篇文章提到的監(jiān)聽Socket，負責綁定監(jiān)聽端口地址，接收客戶端連接并創(chuàng)建用于與客戶端通信的SocketChannel。

不同的IO模型下的實現(xiàn)：

SocketChannel

用于與客戶端通信的SocketChannel，對應于上篇文章提到的客戶端連接Socket，當客戶端完成三次握手后，由系統(tǒng)調(diào)用accept函數(shù)根據(jù)監(jiān)聽Socket創(chuàng)建。

不同的IO模型下的實現(xiàn)：

我們看到在不同IO模型的實現(xiàn)中，Netty這些圍繞IO模型的核心類只是前綴的不同：

BIO對應的前綴為Oio表示old io，現(xiàn)在已經(jīng)廢棄不推薦使用。
NIO對應的前綴為Nio，正是Netty推薦也是我們常用的非阻塞IO模型。
AIO對應的前綴為Aio，由于Linux下的異步IO機制實現(xiàn)的并不成熟，性能提升表現(xiàn)上也不明顯，現(xiàn)已被刪除。

我們只需要將IO模型的這些核心接口對應的實現(xiàn)類前綴改為對應IO模型的前綴，就可以輕松在Netty中完成對IO模型的切換。

多種NIO的實現(xiàn)

我們通常在使用NIO模型的時候會使用Common列下的這些IO模型核心類，Common類也會根據(jù)操作系統(tǒng)的不同自動選擇JDK在對應平臺下的IO多路復用技術(shù)的實現(xiàn)。

而Netty自身也根據(jù)操作系統(tǒng)的不同提供了自己對IO多路復用技術(shù)的實現(xiàn)，比JDK的實現(xiàn)性能更優(yōu)。比如：

JDK的 NIO 默認實現(xiàn)是水平觸發(fā)，Netty 是邊緣觸發(fā)(默認)和水平觸發(fā)可切換。
Netty 實現(xiàn)的垃圾回收更少、性能更好。

我們編寫Netty服務端程序的時候也可以根據(jù)操作系統(tǒng)的不同，采用Netty自身的實現(xiàn)來進一步優(yōu)化程序。做法也很簡單，直接將上圖中紅框里的實現(xiàn)類替換成Netty的自身實現(xiàn)類即可完成切換。

經(jīng)過以上對Netty服務端代碼編寫模板以及IO模型相關(guān)核心類的簡單介紹，我們對Netty的創(chuàng)建流程有了一個簡單粗略的總體認識，下面我們來深入剖析下創(chuàng)建流程過程中的每一個步驟以及這個過程中涉及到的核心類實現(xiàn)。

以下源碼解析部分我們均采用Common列下NIO相關(guān)的實現(xiàn)進行解析。

創(chuàng)建主從Reactor線程組

在Netty服務端程序編寫模板的開始，我們首先會創(chuàng)建兩個Reactor線程組：

一個是主Reactor線程組bossGroup用于監(jiān)聽客戶端連接，創(chuàng)建客戶端連接NioSocketChannel，并將創(chuàng)建好的客戶端連接NioSocketChannel注冊到從Reactor線程組中一個固定的Reactor上。
一個是從Reactor線程組workerGroup，workerGroup中的Reactor負責監(jiān)聽綁定在其上的客戶端連接NioSocketChannel上的IO就緒事件，并處理IO就緒事件，執(zhí)行異步任務。

  //創(chuàng)建主從Reactor線程組
  EventLoopGroup bossGroup = new NioEventLoopGroup(1);
  EventLoopGroup workerGroup = new NioEventLoopGroup();

Netty中Reactor線程組的實現(xiàn)類為NioEventLoopGroup，在創(chuàng)建bossGroup和workerGroup的時候用到了NioEventLoopGroup的兩個構(gòu)造函數(shù)：

帶nThreads參數(shù)的構(gòu)造函數(shù)public NioEventLoopGroup(int nThreads)。
不帶nThreads參數(shù)的默認構(gòu)造函數(shù)public NioEventLoopGroup()。

public class NioEventLoopGroup extends MultithreadEventLoopGroup {
    /**
     * Create a new instance using the default number of threads, the default {@link ThreadFactory} and
     * the {@link SelectorProvider} which is returned by {@link SelectorProvider#provider()}.
     */
    public NioEventLoopGroup() {
        this(0);
    }
    /**
     * Create a new instance using the specified number of threads, {@link ThreadFactory} and the
     * {@link SelectorProvider} which is returned by {@link SelectorProvider#provider()}.
     */
    public NioEventLoopGroup(int nThreads) {
        this(nThreads, (Executor) null);
    }
    ......................省略...........................
}

nThreads參數(shù)表示當前要創(chuàng)建的Reactor線程組內(nèi)包含多少個Reactor線程。不指定nThreads參數(shù)的話采用默認的Reactor線程個數(shù)，用0表示。

最終會調(diào)用到構(gòu)造函數(shù)。

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

下面簡單介紹下構(gòu)造函數(shù)中這幾個參數(shù)的作用，后面我們在講解本文主線的過程中還會提及這幾個參數(shù)，到時在詳細介紹，這里只是讓大家有個初步印象，不必做過多的糾纏。

Executor executor：負責啟動Reactor線程進而Reactor才可以開始工作。

Reactor線程組NioEventLoopGroup負責創(chuàng)建Reactor線程，在創(chuàng)建的時候會將executor傳入。

RejectedExecutionHandler： 當向Reactor添加異步任務添加失敗時，采用的拒絕策略。Reactor的任務不只是監(jiān)聽IO活躍事件和IO任務的處理，還包括對異步任務的處理。這里大家只需有個這樣的概念，后面筆者會專門詳細介紹。
SelectorProvider selectorProvider：Reactor中的IO模型為IO多路復用模型，對應于JDK NIO中的實現(xiàn)為java.nio.channels.Selector(就是我們上篇文章中提到的select,poll,epoll)，每個Reator中都包含一個Selector，用于輪詢注冊在該Reactor上的所有Channel上的IO事件。SelectorProvider就是用來創(chuàng)建Selector的。
SelectStrategyFactory selectStrategyFactory： Reactor最重要的事情就是輪詢注冊其上的Channel上的IO就緒事件，這里的SelectStrategyFactory用于指定輪詢策略，默認為DefaultSelectStrategyFactory.INSTANCE。

最終會將這些參數(shù)交給NioEventLoopGroup的父類構(gòu)造器，下面我們來看下NioEventLoopGroup類的繼承結(jié)構(gòu)：

NioEventLoopGroup類的繼承結(jié)構(gòu)乍一看比較復雜，大家不要慌，筆者會隨著主線的深入慢慢地介紹這些父類接口，我們現(xiàn)在重點關(guān)注Mutithread前綴的類。

我們知道NioEventLoopGroup是Netty中的Reactor線程組的實現(xiàn)，既然是線程組那么肯定是負責管理和創(chuàng)建多個Reactor線程的，所以Mutithread前綴的類定義的行為自然是對Reactor線程組內(nèi)多個Reactor線程的創(chuàng)建和管理工作。

MultithreadEventLoopGroup

public abstract class MultithreadEventLoopGroup extends MultithreadEventExecutorGroup implements EventLoopGroup {
    private static final InternalLogger logger = InternalLoggerFactory.getInstance(MultithreadEventLoopGroup.class);
    //默認Reactor個數(shù)
    private static final int DEFAULT_EVENT_LOOP_THREADS;
    static {
        DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
                "io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2));
        if (logger.isDebugEnabled()) {
            logger.debug("-Dio.netty.eventLoopThreads: {}", DEFAULT_EVENT_LOOP_THREADS);
        }
    }
    /**
     * @see MultithreadEventExecutorGroup#MultithreadEventExecutorGroup(int, Executor, Object...)
     */
    protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
        super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
    }
    ...................省略.....................
}

MultithreadEventLoopGroup類主要的功能就是用來確定Reactor線程組內(nèi)Reactor的個數(shù)。

默認的Reactor的個數(shù)存放于字段DEFAULT_EVENT_LOOP_THREADS中。

從static {}靜態(tài)代碼塊中我們可以看出默認Reactor的個數(shù)的獲取邏輯：

可以通過系統(tǒng)變量 -D io.netty.eventLoopThreads"指定。
如果不指定，那么默認的就是NettyRuntime.availableProcessors() * 2。

當nThread參數(shù)設(shè)置為0采用默認設(shè)置時，Reactor線程組內(nèi)的Reactor個數(shù)則設(shè)置為DEFAULT_EVENT_LOOP_THREADS。

MultithreadEventExecutorGroup

MultithreadEventExecutorGroup這里就是本小節(jié)的核心，主要用來定義創(chuàng)建和管理Reactor的行為。

public abstract class MultithreadEventExecutorGroup extends AbstractEventExecutorGroup {
    //Reactor線程組中的Reactor集合
    private final EventExecutor[] children;
    private final Set readonlyChildren;
    //從Reactor group中選擇一個特定的Reactor的選擇策略 用于channel注冊綁定到一個固定的Reactor上
    private final EventExecutorChooserFactory.EventExecutorChooser chooser;
    /**
     * Create a new instance.
     *
     * @param nThreads          the number of threads that will be used by this instance.
     * @param executor          the Executor to use, or {@code null} if the default should be used.
     * @param args              arguments which will passed to each {@link #newChild(Executor, Object...)} call
     */
    protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
        this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
    }
    ............................省略................................
}

首先介紹一個新的構(gòu)造器參數(shù)EventExecutorChooserFactory chooserFactory。當客戶端連接完成三次握手后，Main Reactor會創(chuàng)建客戶端連接NioSocketChannel，并將其綁定到Sub Reactor Group中的一個固定Reactor，那么具體要綁定到哪個具體的Sub Reactor上呢?這個綁定策略就是由chooserFactory來創(chuàng)建的。默認為DefaultEventExecutorChooserFactory。

下面就是本小節(jié)的主題Reactor線程組的創(chuàng)建過程：

    protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                           EventExecutorChooserFactory chooserFactory, Object... args) {
        if (nThreads <= 0) {
            throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
        }
        if (executor == null) {
            //用于創(chuàng)建Reactor線程
            executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
        }
        children = new EventExecutor[nThreads];
        //循環(huán)創(chuàng)建reaactor group中的Reactor
        for (int i = 0; i < nThreads; i ++) {
            boolean success = false;
            try {
                //創(chuàng)建reactor
                children[i] = newChild(executor, args);
                success = true;
            } catch (Exception e) {
                throw new IllegalStateException("failed to create a child event loop", e);
            } finally {
                     ................省略................
                }
            }
        }
        //創(chuàng)建channel到Reactor的綁定策略
        chooser = chooserFactory.newChooser(children);

         ................省略................

        Set childrenSet = new LinkedHashSet(children.length);
        Collections.addAll(childrenSet, children);
        readonlyChildren = Collections.unmodifiableSet(childrenSet);
    }

1、創(chuàng)建用于啟動Reactor線程的executor

在Netty Reactor Group中的單個Reactor的IO線程模型為上篇文章提到的單Reactor單線程模型，一個Reactor線程負責輪詢注冊其上的所有Channel中的IO就緒事件，處理IO事件，執(zhí)行Netty中的異步任務等工作。正是這個Reactor線程驅(qū)動著整個Netty的運轉(zhuǎn)，可謂是Netty的核心引擎。

而這里的executor就是負責啟動Reactor線程的，從創(chuàng)建源碼中我們可以看到executor的類型為ThreadPerTaskExecutor。

ThreadPerTaskExecutor

public final class ThreadPerTaskExecutor implements Executor {
    private final ThreadFactory threadFactory;
    public ThreadPerTaskExecutor(ThreadFactory threadFactory) {
        this.threadFactory = ObjectUtil.checkNotNull(threadFactory, "threadFactory");
    }
    @Override
    public void execute(Runnable command) {
        threadFactory.newThread(command).start();
    }
}

我們看到ThreadPerTaskExecutor做的事情很簡單，從它的命名前綴ThreadPerTask我們就可以猜出它的工作方式，就是來一個任務就創(chuàng)建一個線程執(zhí)行。而創(chuàng)建的這個線程正是netty的核心引擎Reactor線程。

在Reactor線程啟動的時候，Netty會將Reactor線程要做的事情封裝成Runnable，丟給exexutor啟動。

而Reactor線程的核心就是一個死循環(huán)不停的輪詢IO就緒事件，處理IO事件，執(zhí)行異步任務。一刻也不停歇，堪稱996典范。

這里向大家先賣個關(guān)子，"Reactor線程是何時啟動的呢??"

2、創(chuàng)建ReactorReactor

線程組NioEventLoopGroup包含多個Reactor，存放于private final EventExecutor[] children數(shù)組中。

所以下面的事情就是創(chuàng)建nThread個Reactor，并存放于EventExecutor[] children字段中，

我們來看下用于創(chuàng)建Reactor的newChild(executor, args)方法：

newChild

newChild方法是MultithreadEventExecutorGroup中的一個抽象方法，提供給具體子類實現(xiàn)。

protected abstract EventExecutor newChild(Executor executor, Object... args) throws Exception;

這里我們解析的是NioEventLoopGroup，我們來看下newChild在該類中的實現(xiàn)：

public class NioEventLoopGroup extends MultithreadEventLoopGroup {
    @Override
    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);
    }
}

前邊提到的眾多構(gòu)造器參數(shù)，這里會通過可變參數(shù)Object... args傳入到Reactor類NioEventLoop的構(gòu)造器中。

這里介紹下新的參數(shù)EventLoopTaskQueueFactory queueFactory，前邊提到Netty中的Reactor主要工作是輪詢注冊其上的所有Channel上的IO就緒事件，處理IO就緒事件。除了這些主要的工作外，Netty為了極致的壓榨Reactor的性能，還會讓它做一些異步任務的執(zhí)行工作。既然要執(zhí)行異步任務，那么Reactor中就需要一個隊列來保存任務。

這里的EventLoopTaskQueueFactory就是用來創(chuàng)建這樣的一個隊列來保存Reactor中待執(zhí)行的異步任務。

可以把Reactor理解成為一個單線程的線程池，類似于JDK中的SingleThreadExecutor，僅用一個線程來執(zhí)行輪詢IO就緒事件，處理IO就緒事件，執(zhí)行異步任務。同時待執(zhí)行的異步任務保存在Reactor里的taskQueue中。

NioEventLoop

public final class NioEventLoop extends SingleThreadEventLoop {
    //用于創(chuàng)建JDK NIO Selector,ServerSocketChannel
    private final SelectorProvider provider;
    //Selector輪詢策略 決定什么時候輪詢，什么時候處理IO事件，什么時候執(zhí)行異步任務
    private final SelectStrategy selectStrategy;
    /**
     * The NIO {@link Selector}.
     */
    private Selector selector;
    private Selector unwrappedSelector;
    NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider,
                 SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler,
                 EventLoopTaskQueueFactory queueFactory) {
        super(parent, executor, false, newTaskQueue(queueFactory), newTaskQueue(queueFactory),
                rejectedExecutionHandler);
        this.provider = ObjectUtil.checkNotNull(selectorProvider, "selectorProvider");
        this.selectStrategy = ObjectUtil.checkNotNull(strategy, "selectStrategy");
        final SelectorTuple selectorTuple = openSelector();
        this.selector = selectorTuple.selector;
        this.unwrappedSelector = selectorTuple.unwrappedSelector;
    }
}

這里就正式開始了Reactor的創(chuàng)建過程，我們知道Reactor的核心是采用的IO多路復用模型來對客戶端連接上的IO事件進行監(jiān)聽，所以最重要的事情是創(chuàng)建Selector(JDK NIO 中IO多路復用技術(shù)的實現(xiàn))。

可以把Selector理解為我們上篇文章介紹的Select,poll,epoll，它是JDK NIO對操作系統(tǒng)內(nèi)核提供的這些IO多路復用技術(shù)的封裝。

openSelector

openSelector是NioEventLoop類中用于創(chuàng)建IO多路復用的Selector，并對創(chuàng)建出來的JDK NIO 原生的Selector進行性能優(yōu)化。

首先會通過SelectorProvider#openSelector創(chuàng)建JDK NIO原生的Selector。

 private SelectorTuple openSelector() {
        final Selector unwrappedSelector;
        try {
            //通過JDK NIO SelectorProvider創(chuàng)建Selector
            unwrappedSelector = provider.openSelector();
        } catch (IOException e) {
            throw new ChannelException("failed to open a new selector", e);
        }

        ..................省略.............
}

SelectorProvider會根據(jù)操作系統(tǒng)的不同選擇JDK在不同操作系統(tǒng)版本下的對應Selector的實現(xiàn)。Linux下會選擇Epoll，Mac下會選擇Kqueue。

下面我們就來看下SelectorProvider是如何做到自動適配不同操作系統(tǒng)下IO多路復用實現(xiàn)的。

SelectorProvider

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

SelectorProvider是在前面介紹的NioEventLoopGroup類構(gòu)造函數(shù)中通過調(diào)用SelectorProvider.provider()被加載，并通過NioEventLoopGroup#newChild方法中的可變長參數(shù)Object... args傳遞到NioEventLoop中的private final SelectorProvider provider字段中。

SelectorProvider的加載過程：

public abstract class SelectorProvider {
    public static SelectorProvider provider() {
        synchronized (lock) {
            if (provider != null)
                return provider;
            return AccessController.doPrivileged(
                new PrivilegedAction() {
                    public SelectorProvider run() {
                            if (loadProviderFromProperty())
                                return provider;
                            if (loadProviderAsService())
                                return provider;
                            provider = sun.nio.ch.DefaultSelectorProvider.create();
                            return provider;
                        }
                    });
        }
    }
}

從SelectorProvider加載源碼中我們可以看出，SelectorProvider的加載方式有三種，優(yōu)先級如下：

通過系統(tǒng)變量-D java.nio.channels.spi.SelectorProvider指定SelectorProvider的自定義實現(xiàn)類全限定名。通過應用程序類加載器(Application Classloader)加載。

通過SPI方式加載。在工程目錄META-INF/services下定義名為java.nio.channels.spi.SelectorProvider的SPI文件，文件中第一個定義的SelectorProvider實現(xiàn)類全限定名就會被加載。

  private static boolean loadProviderAsService() {
        ServiceLoader sl =
            ServiceLoader.load(                                                

                                                新聞標題：聊聊Netty那些事兒之Reactor在Netty中的實現(xiàn)(創(chuàng)建篇)                                                

                                                本文URL：http://fisionsoft.com.cn/article/dpisddo.html