簡介
使用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，否則可能會得不到想要的結果。
到此這篇關于基于Java在netty中實現線程和CPU綁定的文章就介紹到這了,更多相關 線程和CPU綁定內容請搜索html5模板網以前的文章希望大家以后多多支持html5模板網！