简介

之前咱们介绍了一个十分优良的细粒度管制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/

最艰深的解读，最粗浅的干货，最简洁的教程，泛滥你不晓得的小技巧等你来发现！

欢送关注我的公众号:「程序那些事」,懂技术，更懂你！