netty系列之:在netty中實現執行緒和CPU繫結

flydean 發表於 2022-06-29
Netty CPU

簡介

之前我們介紹了一個非常優秀的細粒度控制JAVA執行緒的庫:java thread affinity。使用這個庫你可以將執行緒繫結到特定的CPU或者CPU核上,通過減少執行緒在CPU之間的切換,從而提升執行緒執行的效率。

雖然netty已經夠優秀了,但是誰不想更加優秀一點呢?於是一個想法產生了,那就是能不能把affinity庫用在netty中呢?

答案是肯定的,一起來看看吧。

引入affinity

affinity是以jar包的形式提供出去的,目前最新的正式版本是3.20.0,所以我們需要這樣引入:

<!-- https://mvnrepository.com/artifact/net.openhft/affinity -->
<dependency>
    <groupId>net.openhft</groupId>
    <artifactId>affinity</artifactId>
    <version>3.20.0</version>
</dependency>

引入affinity之後,會在專案的依賴庫中新增一個affinity的lib包,這樣我們就可以在netty中愉快的使用affinity了。

AffinityThreadFactory

有了affinity,怎麼把affinity引入到netty中呢?

我們知道affinity是用來控制執行緒的,也就是說affinity是跟執行緒有關的。而netty中跟執行緒有關的就是EventLoopGroup,先看一下netty中EventLoopGroup的基本用法,這裡以NioEventLoopGroup為例,NioEventLoopGroup有很多建構函式的引數,其中一種是傳入一個ThreadFactory:

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

這個建構函式表示NioEventLoopGroup中使用的執行緒都是由threadFactory建立而來的。這樣以來我們就找到了netty和affinity的對應關係。只需要構造affinity的ThreadFactory即可。

剛好affinity中有一個AffinityThreadFactory類,專門用來建立affinity對應的執行緒。

接下來我們來詳細瞭解一下AffinityThreadFactory。

AffinityThreadFactory可以根據提供的不同AffinityStrategy來建立對應的執行緒。

AffinityStrategy表示的是執行緒之間的關係。在affinity中,有5種執行緒關係,分別是:

    SAME_CORE - 執行緒會執行在同一個CPU core中。
    SAME_SOCKET - 執行緒會執行在同一個CPU socket中,但是不在同一個core上。
    DIFFERENT_SOCKET - 執行緒會執行在不同的socket中。
    DIFFERENT_CORE - 執行緒會執行在不同的core上。
    ANY - 只要是可用的CPU資源都可以。

這些關係是通過AffinityStrategy中的matches方法來實現的:

boolean matches(int cpuId, int cpuId2);

matches傳入兩個引數,分別是傳入的兩個cpuId。我們以SAME_CORE為例來看看這個mathes方法到底是怎麼工作的:

    SAME_CORE {
        @Override
        public boolean matches(int cpuId, int cpuId2) {
            CpuLayout cpuLayout = AffinityLock.cpuLayout();
            return cpuLayout.socketId(cpuId) == cpuLayout.socketId(cpuId2) &&
                    cpuLayout.coreId(cpuId) == cpuLayout.coreId(cpuId2);
        }
    }

可以看到它的邏輯是先獲取當前CPU的layout,CpuLayout中包含了cpu個數,sockets個數,每個sockets的cpu核數等基本資訊。並且提供了三個方法根據給定的cpuId返回對應的socket、core和thread資訊:

    int socketId(int cpuId);

    int coreId(int cpuId);

    int threadId(int cpuId);

matches方法就是根據傳入的cpuId找到對應的socket,core資訊進行比較,從而生成了5中不同的策略。

先看一下AffinityThreadFactory的建構函式:

    public AffinityThreadFactory(String name, boolean daemon, @NotNull AffinityStrategy... strategies) {
        this.name = name;
        this.daemon = daemon;
        this.strategies = strategies.length == 0 ? new AffinityStrategy[]{AffinityStrategies.ANY} : strategies;
    }

可以傳入thread的name字首,和是否是守護執行緒,最後如果strategies不傳的話,預設使用的是AffinityStrategies.ANY策略,也就是說為執行緒分配任何可以繫結的CPU。

接下來看下這個ThreadFactory是怎麼建立新執行緒的:

public synchronized Thread newThread(@NotNull final Runnable r) {
        String name2 = id <= 1 ? name : (name + '-' + id);
        id++;
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                try (AffinityLock ignored = acquireLockBasedOnLast()) {
                    r.run();
                }
            }
        }, name2);
        t.setDaemon(daemon);
        return t;
    }

    private synchronized AffinityLock acquireLockBasedOnLast() {
        AffinityLock al = lastAffinityLock == null ? AffinityLock.acquireLock() : lastAffinityLock.acquireLock(strategies);
        if (al.cpuId() >= 0)
            lastAffinityLock = al;
        return al;
    }

從上面的程式碼可以看出,建立的新執行緒會以傳入的name為字首,後面新增1,2,3,4這種字尾。並且根據傳入的是否是守護執行緒的標記,將呼叫對應執行緒的setDaemon方法。

重點是Thread內部執行的Runnable內容,在run方法內部,首先呼叫acquireLockBasedOnLast方法獲取lock,在獲得lock的前提下執行對應的執行緒方法,這樣就會將當前執行的Thread和CPU進行繫結。

從acquireLockBasedOnLast方法中,我們可以看出AffinityLock實際上是一個鏈式結構,每次請求的時候都呼叫的是lastAffinityLock的acquireLock方法,如果獲取到lock,則將lastAffinityLock進行替換,用來進行下一個lock的獲取。

有了AffinityThreadFactory,我們只需要在netty的使用中傳入AffinityThreadFactory即可。

在netty中使用AffinityThreadFactory

上面講到了要在netty中使用affinity,可以將AffinityThreadFactory傳入EventLoopGroup中。對於netty server來說可以有兩個EventLoopGroup,分別是acceptorGroup和workerGroup,在下面的例子中我們將AffinityThreadFactory傳入workerGroup,這樣後續work中分配的執行緒都會遵循AffinityThreadFactory中配置的AffinityStrategies策略,來獲得對應的CPU:

//建立兩個EventloopGroup用來處理連線和訊息
        EventLoopGroup acceptorGroup = new NioEventLoopGroup(acceptorThreads);
        //建立AffinityThreadFactory
        ThreadFactory threadFactory = new AffinityThreadFactory("affinityWorker", AffinityStrategies.DIFFERENT_CORE,AffinityStrategies.DIFFERENT_SOCKET,AffinityStrategies.ANY);
        //將AffinityThreadFactory加入workerGroup
        EventLoopGroup workerGroup = new NioEventLoopGroup(workerThreads,threadFactory);
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(acceptorGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new AffinityServerHandler());
                        }
                    })
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true);

            // 繫結埠並開始接收連線
            ChannelFuture f = b.bind(port).sync();

            // 等待server socket關閉
            f.channel().closeFuture().sync();
        } finally {
            //關閉group
            workerGroup.shutdownGracefully();
            acceptorGroup.shutdownGracefully();
        }

為了獲取更好的效能,Affinity還可以對CPU進行隔離,被隔離的CPU只允許執行本應用的執行緒,從而獲得更好的效能。

要使用這個特性需要用到linux的isolcpus。這個功能主要是將一個或多個CPU獨立出來,用來執行特定的Affinity任務。

isolcpus命令後面可以接CPU的ID,或者可以修改/boot/grub/grub.conf檔案,新增要隔離的CPU資訊如下:

isolcpus=3,4,5

總結

affinity可以對執行緒進行極致管控,對效能要求嚴格的朋友可以試試,但是在使用過程中需要選擇合適的AffinityStrategies,否則可能會得不到想要的結果。

本文的例子可以參考:learn-netty4

更多內容請參考 http://www.flydean.com/51-netty-thread-affinity/

最通俗的解讀,最深刻的乾貨,最簡潔的教程,眾多你不知道的小技巧等你來發現!

歡迎關注我的公眾號:「程式那些事」,懂技術,更懂你!

相關文章