JcTools中队列性能测试记录

最新推荐文章于 2024-05-10 09:49:21 发布
最新推荐文章于 2024-05-10 09:49:21 发布
阅读量86 收藏
点赞数 1
文章标签： java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51320830/article/details/134702558
版权

对JcTools中MPMC和SPMC两种队列的性能进行测试、计较并记录。

JcTools中队列性能测试

前言

记录一下使用JcTools的MPMC和SPMC两种无锁队列的性能比较。

一、搭建项目

maven依赖

<dependency>
    <groupId>org.jctools</groupId>
    <artifactId>jctools-core</artifactId>
    <version>4.0.2</version>
</dependency>
<dependency>
   <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.24</version>
</dependency>

二、编写代码

1. 引入库

代码如下（示例）：
Main

public class Main {

    public static final String JCTOOLS_TYPE = "jctools.type";
    public static final String JCTOOLS_MESSAGE_SIZE = "jctools.message.size";
    public static final String JCTOOLS_QUEUE_SIZE = "jctools.queue.size";
    public static final String JCTOOLS_PRODUCER_THREAD_MIN = "jctools.producer.thread.min";
    public static final String JCTOOLS_PRODUCER_THREAD_MAX = "jctools.producer.thread.max";
    public static final String JCTOOLS_PRODUCER_QUEUE_SIZE = "jctools.producer.queue.size";
    public static final String JCTOOLS_CONSUMER_QUEUE_SIZE = "jctools.consumer.queue.size";
    public static final String JCTOOLS_CONSUMER_THREAD_MIN = "jctools.consumer.thread.min";
    public static final String JCTOOLS_CONSUMER_THREAD_MAX = "jctools.consumer.thread.max";
    public static final String JCTOOLS_CONSUMER_SLEEP = "jctools.consumer.sleep";

    public static void main(String[] args) {
        String type = System.getProperty(JCTOOLS_TYPE);
        Integer messageSize = Integer.valueOf(System.getProperty(JCTOOLS_MESSAGE_SIZE));
        Integer queueSize = Integer.valueOf(System.getProperty(JCTOOLS_QUEUE_SIZE));
        Integer produceMin = Integer.valueOf(System.getProperty(JCTOOLS_PRODUCER_THREAD_MIN));
        Integer produceMax = Integer.valueOf(System.getProperty(JCTOOLS_PRODUCER_THREAD_MAX));
        Integer produceQueueSize = Integer.valueOf(System.getProperty(JCTOOLS_PRODUCER_QUEUE_SIZE));
        Integer consumeQueueSize = Integer.valueOf(System.getProperty(JCTOOLS_CONSUMER_QUEUE_SIZE));
        Integer consumeMin = Integer.valueOf(System.getProperty(JCTOOLS_CONSUMER_THREAD_MIN));
        Integer consumeMax = Integer.valueOf(System.getProperty(JCTOOLS_CONSUMER_THREAD_MAX));
        Integer consumeSleep = Integer.valueOf(System.getProperty(JCTOOLS_CONSUMER_SLEEP));
        Result result = null;
        if ("mpmc".equals(type)) {
            System.out.println("===========================【" + type + "】测试开始===========================");
            MpmcTest mpmcTest = MpmcTest.INSTANCE;
            mpmcTest.setMessageSize(messageSize);
            mpmcTest.setQueueSize(queueSize);
            mpmcTest.setConsumerExecutor(new ThreadPoolExecutor(consumeMin, consumeMax, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(consumeQueueSize), new ThreadPoolExecutor.CallerRunsPolicy()));
            mpmcTest.setProducerExecutor(new ThreadPoolExecutor(produceMin, produceMax, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(produceQueueSize), new ThreadPoolExecutor.CallerRunsPolicy()));
            mpmcTest.setSleepTime(consumeSleep);
            result = mpmcTest.test();
        }
        if ("spmc".equals(type)) {
            System.out.println("===========================【" + type + "】测试开始===========================");
            SpmcTest spmcTest = SpmcTest.INSTANCE;
            spmcTest.setMessageSize(messageSize);
            spmcTest.setQueueSize(queueSize);
            spmcTest.setConsumerExecutor(new ThreadPoolExecutor(consumeMin, consumeMax, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(consumeQueueSize), new ThreadPoolExecutor.CallerRunsPolicy()));
            spmcTest.setProducerExecutor(Executors.newSingleThreadExecutor());
            spmcTest.setSleepTime(consumeSleep);
            result = spmcTest.test();
        }
        if (result != null) {
            System.out.println("===========================【" + type + "】测试结束===========================");
            System.out.println("发送成功数：\t" + result.getProduceSuccess());
            System.out.println("发送失败数：\t" + result.getProduceFail());
            System.out.println("消费成功数：\t" + result.getConsumeSuccess());
            System.out.println("消费失败数：\t" + result.getConsumeFail());
            System.out.println("总耗时：\t" + result.getDurTime()/1000000);
        }
    }
}

Result

@Data
public class Result {
    private Integer consumeSuccess = 0;
    private Integer consumeFail = 0;
    private Integer produceSuccess = 0;
    private Integer produceFail = 0;
    private Long durTime = 0L;
}

MpmcTest 

@Data
public class MpmcTest {
    private MpmcTest() {
    }

    public static final MpmcTest INSTANCE = new MpmcTest();

    private ThreadPoolExecutor producerExecutor;

    private ThreadPoolExecutor consumerExecutor;

    private Integer messageSize;

    private Integer queueSize;

    private Integer sleepTime;

    private String prefix = "mpmc_thread_";
    private static AtomicInteger consumeSuccess = new AtomicInteger(0);
    private static AtomicInteger consumeFail = new AtomicInteger(0);
    private static AtomicInteger produceSuccess = new AtomicInteger(0);
    private static AtomicInteger produceFail = new AtomicInteger(0);

    public Result test() {
        MpmcArrayQueue<Long> queue = new MpmcArrayQueue<>(this.queueSize);
//        CountDownLatch countDownLatch = new CountDownLatch(messageSize);
        long startTime = System.nanoTime();
        for (int i = 0; i < messageSize; i++) {
            Long index = (long) i;
            producerExecutor.execute(() -> {
                while (!queue.offer(index)) {
                    System.out.println("===================任务发布失败，线程：" + prefix + index);
                    produceFail.getAndIncrement();
                }
                System.out.println("===================任务发布成功，线程：" + prefix + index);
                produceSuccess.getAndIncrement();
                consumerExecutor.execute(() -> {
                    Long retIndex = queue.poll();
                    if (retIndex == null) {
                        System.out.println(">>>>>>>>>>>>>>>>>>消费失败，线程：" + prefix + retIndex);
                        consumeFail.getAndIncrement();
                    } else {
                        System.out.println("消费成功，线程：" + prefix + retIndex);
                        consumeSuccess.getAndIncrement();
                        try {
                            Thread.sleep(sleepTime);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    if (messageSize <= (consumeSuccess.get() + consumeFail.get())) {
                        consumerExecutor.shutdown();
                    }
//                    countDownLatch.countDown();
                });
            });
        }
        Result result = new Result();
        try {
//            countDownLatch.await(120, TimeUnit.SECONDS);
//            System.out.println("countDown"+countDownLatch.getCount());
//            consumerExecutor.shutdownNow();
            if (consumerExecutor.awaitTermination(Long.MAX_VALUE, TimeUnit.MINUTES)) {
                result.setConsumeSuccess(consumeSuccess.get());
                result.setConsumeFail(consumeFail.get());
                result.setProduceSuccess(produceSuccess.get());
                result.setProduceFail(produceFail.get());
                result.setDurTime(System.nanoTime() - startTime);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return result;
    }
}

SpmcTest 

@Data
public class SpmcTest {
    private SpmcTest() {
    }

    public static final SpmcTest INSTANCE = new SpmcTest();

    private ExecutorService producerExecutor;

    private ExecutorService consumerExecutor;

    private Integer messageSize;

    private Integer queueSize;

    private Integer sleepTime;

    private String prefix = "spmc_thread_";

    public Result test() {
        MpmcArrayQueue<Long> queue = new MpmcArrayQueue<>(this.queueSize);
        AtomicInteger consumeSuccess = new AtomicInteger();
        AtomicInteger consumeFail = new AtomicInteger();
        AtomicInteger produceSuccess = new AtomicInteger();
        AtomicInteger produceFail = new AtomicInteger();
        long startTime = System.nanoTime();
        for (int i = 0; i < messageSize; i++) {
            Long index = (long) i;
            producerExecutor.execute(() -> {
                while (!queue.offer(index)) {
                    produceFail.getAndIncrement();
                }
                produceSuccess.getAndIncrement();
                consumerExecutor.execute(() -> {
                    Long retIndex = queue.poll();
                    if (retIndex == null) {
                        System.out.println("===================消费失败，线程：" + prefix + retIndex);
                        consumeFail.getAndIncrement();
                    } else {
                        System.out.println("消费成功，线程：" + prefix + retIndex);
                        consumeSuccess.getAndIncrement();
                        try {
                            Thread.sleep(sleepTime);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    if (messageSize <= (consumeSuccess.get() + consumeFail.get())) {
                        consumerExecutor.shutdown();
                    }
                });
            });
        }
        Result result = new Result();
        try {
            if (consumerExecutor.awaitTermination(Long.MAX_VALUE, TimeUnit.MINUTES)) {
                result.setConsumeSuccess(consumeSuccess.get());
                result.setConsumeFail(consumeFail.get());
                result.setProduceSuccess(produceSuccess.get());
                result.setProduceFail(produceFail.get());
                result.setDurTime(System.nanoTime() - startTime);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return result;
    }
}

三、构建脚本并测试

1. 构建启动脚本

在Idea里添加如下配置

-Djctools.type=mpmc -Djctools.message.size=100000 -Djctools.queue.size=20000 -Djctools.producer.thread.min=10 -Djctools.producer.thread.max=40 -Djctools.producer.queue.size=10000 -Djctools.consumer.thread.min=20 -Djctools.consumer.thread.max=80 -Djctools.consumer.queue.size=20000 -Djctools.consumer.sleep=5

2. 更换条件，获取结果

方案一
数据量 100000 queueSize 10000 生产线程：10 40 10000 消费线程：20 80 20000 消费时间 5ms
SPMC 6793 qps 14,705 cpu 1% 内存 10m
MPMC 5327 qps 18,867 cpu 1% 内存 10m

方案二
数据量 1000000 queueSize 10000 生产线程：10 40 10000 消费线程：20 80 20000 消费时间 5ms
SPMC 69511 qps 14,388 cpu 3% 内存 170m
MPMC 47436 qps 21,097 cpu 1% 内存 100m

方案三
数据量 1000000 queueSize 10000 生产线程：10 40 10000 消费线程：200 800 20000 消费时间 5ms
SPMC 12492 qps 80,000 cpu 2% 内存200m
MPMC 16457 qps 62,500 cpu 2% 内存150m

方案四
数据量 10000000 queueSize 10000 生产线程：10 40 10000 消费线程：200 800 20000 消费时间 5ms
SPMC 108148 qps 92,592 cpu 初始8%(4s) 后2% 内存 峰值2833m 均值2000m
MPMC 142194 qps 70,373 cpu 2% 内存150m

方案五
数据量 10000000 queueSize 10000 生产线程：100 400 10000 消费线程：200 800 20000 消费时间 5ms
SPMC 107203 qps 92,592 cpu 初始8%(4s) 后2% 内存 峰值2833m 均值2000m
MPMC 161223 qps 161223 cpu 2% 内存150m

方案六
数据量 10000000 queueSize 10000 生产线程：100 400 100000 消费线程：200 800 20000 消费时间 5ms
SPMC 107203 qps 92,592 cpu 初始8%(4s) 后2% 内存 峰值2833m 均值2000m
MPMC 145828 qps 161223 cpu 2% 内存150m

方案七
数据量 10000000 queueSize 10000 生产线程：100 400 100000 消费线程：200 800 200000 消费时间 5ms
SPMC 107203 qps 92,592 cpu 初始8%(4s) 后2% 内存 峰值2833m 均值2000m
MPMC N/A qps N/A cpu 2% 内存150m 大量线程发布失败，93s执行470000

方案七
数据量 10000000 queueSize 100000 生产线程：100 400 100000 消费线程：200 800 200000 消费时间 5ms
SPMC 286462 qps 92,592 cpu 初始8%(4s) 后2% 内存 峰值2425m 均值2000m 出现大量发送失败，但最终都成功；发送成功数10000000；发送失败数2084979727
MPMC N/A qps N/A cpu 2% 内存150m 大量线程发布失败，5‘33s执行1223724

方案八
数据量 10000000 queueSize 40000 生产线程400 1000 20000 消费线程：1000 4000 40000 消费时间 5ms
SPMC 151742 qps 92,592 cpu 初始8%(4s) 后2% 内存 峰值2825m 均值2000m
MPMC 208681 qps cpu 2% 内存150m

方案九
数据量 10000000 queueSize 10000 生产线程400 1000 20000 消费线程：1000 4000 40000 消费时间 5ms
SPMC 144742 qps 92,592 cpu 初始8%(4s) 后2% 内存 峰值2825m 均值2000m 出现大量发送失败，但最终都成功；发送成功数10000000；发送失败数-1276524988
MPMC 208681 qps cpu 2% 内存150m

总结

未完待续

未阳丶
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JCTools简介-增强的并发工具
liinux-Talk is cheap,show me the code.
06-14 7571
JCTools 早在96年就有论文提出了无锁队列的概念，再到后来 Disruptor，高性能已得到生产的验证。此处介绍的 Jctools 中的高性能队列，其性能丝毫不输于 Disruptor。 JCTools (Java Concurrency Tools) 提供了一系列非阻塞并发数据结构（标准 Java 中缺失的），当存在线程争抢的时候，非阻塞并发数据结构比阻塞并发数据结构能提供更好的性能。 JCTools 是一个开源工具包，在 Apache License 2.0 下发布，并在 Netty、Rxj
systemVerilog中队列的例子
11-15
SystemVerilog 中队列广泛应用于数字电路设计、验证和测试中。 队列的主要操作包括： * enqueue（入队）：将元素添加到队列的末尾。 * dequeue（出队）：从队列的头部删除元素。 * size（队列大小）：返回队列中的...
Netty解读：高性能无锁队列Jctools源码分析
TheLudlows的博客
05-28 4300
文章目录JDK BlockingQueue队列概述MpscArrayQueueofferpollMpscCompoundQueueofferpollMpscChunkedArrayQueueofferpoll优化总结lazy set大量的位运算伪共享无锁测试代码地址扩展阅读 JDK BlockingQueue队列概述 在Java中用的最多的也就是BlockingQueue，所谓的Blocking就...
探索高效的并发处理工具——JCTools
最新发布
gitblog_00026的博客
05-10 304
探索高效的并发处理工具——JCTools 项目地址:https://gitcode.com/JCTools/JCTools 1、项目介绍 JCTools 是一个专为Java虚拟机（JVM）设计的并发工具包。它弥补了JDK中现有的并发数据结构的不足，提供了多种高效且线程安全的队列实现。这个开源项目由Java开发者社区共同维护，已经得到了Netty、RxJava等知名框架的采用，并在商业产品中取得了良...
JCTools Mpsc源码详解(一)
冯宝宝
08-21 578
可以看出Jctools提供八种Mpsc的具体实现分别针对不同的生产者消费者场景,Jctools提供的Mpscqueue高性能的主要原因是文章开始提到的几种方案,以及对应的具体实现的一些优化技巧,本身使用还是基本的队列操作,屏蔽了底层的实现细节,具体分析几种经典的实现;伪共享问题只发生在不同线程对同一cacheline中的不同变量访问的情况下---如果多个线程对同一个变量使用那就必须每次做同步操作,另外如果多个变量存在于不同的cacheline中的话也不存在伪共享问题。具体的Mpsc实现看后续的文章;
秒懂：JCTool 的 Mpsc 高性能无锁队列 (史上最全+10W字长文)
架构师尼恩
12-12 4768
MpscQueue由一系列数组构成，数组的最后一个元素指向下一个数组，形成单向链表。MpscQueue全程无锁化，非阻塞，相较于JDK提供的同步阻塞队列，性能有很好的提升，这也是Netty后来的版本将任务队列替换为JCtools的重要原因。在生产过程中，它用到了大量的CAS操作，对于需要做并发控制的地方，确保只有一个线程会执行成功，其他CAS失败的线程会自旋重试，全程都是无锁非阻塞的。不管是扩容，还是等待元素被填充到数组，这些过程都是会极快完成的，因此短暂的自旋会比线程挂起再唤醒效率更高。
OPNET模拟仿真QoS中队列策略机制
05-15
OPNET模拟仿真QoS中队列策略机制 opnet关于服务质量的研究，如丢包率，网路时延等等 非原创，仅供学习研究，如侵犯您的权益，请联系移除
中队辅导员培训记录.doc
02-17
中队辅导员培训记录.doc
中队辅导员培训记录.pdf
12-03
中队辅导员培训记录.pdf
JAVA 项目问题排查过程
建伟博客
12-29 3316
现象 收到系统报警，查看一台机器频繁FULLGC，且该服务超时。 这是一台4核8G的机器, 使用jdk1.8.0_45-b14。 https://liuzhengyang.github.io/2017/03/21/jvmtroubleshooting/ 我们可以直接通过jstat等来观察。这次我先通过CPU开始。top查看后该java进程的运行状况为   1 2...
jctools-core-2.1.1-API文档-中英对照版.zip
03-30
赠送jar包：jctools-core-2.1.1.jar 赠送原API文档：jctools-core-2.1.1-javadoc.jar 赠送源代码：jctools-core-2.1.1-sources.jar 包含翻译后的API文档：jctools-core-2.1.1-javadoc-API文档-中文(简体)-英语-对照版.zip 对应Maven信息：groupId：org.jctools，artifactId：jctools-core，version：2.1.1 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。 双语对照，边学技术、边学英语。
JCToolsJDK中缺失的并发工具
08-06
JCTools：JDK中缺失的并发工具
JCTools简介
weixin_33735077的博客
09-04 425
序 JCTools是一款对jdk并发数据结构进行增强的并发工具，主要提供了map以及queue的增强数据结构。原来netty还是自己写的MpscLinkedQueueNode，后来新版本就换成使用JCTools的并发队列了。 增强map ConcurrentAutoTable(后面几个map/set结构的基础) NonBlockingH...
JCTools, 场景特化的并发工具
weixin_34408624的博客
02-05 1036
同上一篇一样，在jmap -histo中发现MpscChunkedArrayQueue类的实例比较多，javadoc看了下，其原来是出自JC Tools，https://github.com/JCTools/JCTools。 通过官网，我们可以看到，它针对实际的场景对JDK自带的并发队列做了一些特定的优化，如下： Java Concurrency Tools for the JVM. This p...
JCTools
04stone37
09-11 662
JCTools是一款对jdk并发数据结构进行增强的并发工具，主要提供了map以及queue的增强数据结构。增强mapConcurrentAutoTable(后面几个map/set结构的基础) NonBlockingHashMap NonBlockingHashMapLong NonBlockingHashSet NonBlockingIdentityHashMap NonBlockingS
Jctools Queue队列
weixin_40757126的博客
05-09 525
JCTools是一款对jdk并发数据结构进行增强的并发工具，主要提供了非阻塞Map以及无锁Queue的增强数据结构，关于NonBlockingHashMap 源码分析我写了篇文章。 如果还不了解CAS，可以参考这个博客http://blog.csdn.net/hsuxu/article/details/9467651 主要说下JCTools中的Queue，和jdk中的Queue比性能有很大的提升，主要实现利用了CAS和填充缓存行（避免伪共享），典型的空间换时间，然后我在百度时很多文章千篇一律不知道是不是抄袭
手写封装JavaScript工具函数-JcTools
qq_53109172的博客
01-05 223
JcTools 中封装了一些 JavaScript 中常用的工具函数，可以帮助你快速完成一些功能，例如：防抖、节流、深拷贝、获取时间、随机颜色、数组合并等等
Netty源码分析---MpscLinkedQueue
凌霄的专栏
11-18 2269
 MpscLinkedQueue是netty自己实现的线程安全的队列，与JDK通过
c#中队列
05-29
C#中的队列可以通过System.Collections命名空间中的Queue类来实现。队列是一种先进先出（FIFO）的数据结构，可以在队列的末尾添加元素，从队列的开头移除元素。以下是一个简单的示例代码： ``` using System; using System.Collections; class Program { static void Main(string[] args) { Queue myQueue = new Queue(); myQueue.Enqueue("apple"); myQueue.Enqueue("banana"); myQueue.Enqueue("orange"); Console.WriteLine($"队列中的元素个数：{myQueue.Count}"); // 遍历队列 foreach (string fruit in myQueue) { Console.WriteLine(fruit); } // 移除队列的第一个元素 string firstFruit = (string)myQueue.Dequeue(); Console.WriteLine($"移除的元素是：{firstFruit}"); Console.WriteLine($"队列中的元素个数：{myQueue.Count}"); // 查看队列的第一个元素 string nextFruit = (string)myQueue.Peek(); Console.WriteLine($"队列的下一个元素是：{nextFruit}"); } } ``` 运行结果： ``` 队列中的元素个数：3 apple banana orange 移除的元素是：apple 队列中的元素个数：2 队列的下一个元素是：banana ``` 在上面的示例代码中，首先创建了一个空的队列`myQueue`，然后使用`Enqueue`方法向队列中添加元素。使用`Count`属性可以获取队列中的元素个数。使用`foreach`循环可以遍历整个队列。使用`Dequeue`方法可以移除队列中的第一个元素，并将其返回。使用`Peek`方法可以查看队列中的下一个元素，但不会将其移除。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值