java中Disruptor性能测试笔记

硬件描述:

model name      : Intel(R) Xeon(R) CPU E5-2640 0 @ 2.50GHz

cpu core      : 4

cache size      : 15360 KB

OS      : Linux 64bit

JDK      : 1.7.0_21-b11

Disruptor 3.2.1:

ringBufferSize      :  1024

producerType      :  ProducerType.MULTI

WaitStrategy      :  BlockingWaitStrategy

测试代码(dtest.zip common-disruptor):

 代码如下 复制代码

package org.chinasb.test;
 
import java.util.concurrent.CountDownLatch;
 
import org.chinasb.common.disruptor.Event;
import org.chinasb.common.disruptor.dispatch.Dispatcher;
import org.chinasb.common.disruptor.dispatch.RingbufferDispatcher;
 
public class Test {
    static long LOGIC_LOOP = 0;
    static long COST = 0;
    static int NUM = 5000000;
 
    public static void main(String[] args) {
        boolean multithread = false;
        int bufferSize = 1024;
        if (args.length > 0) {
            if (args.length > 0) {
                NUM = Integer.parseInt(args[0]);
            }
            if (args.length > 1) {
                multithread = Boolean.parseBoolean(args[1]);
            }
            if (args.length > 2) {
                bufferSize = Integer.parseInt(args[2]);
            }
            if (args.length > 3) {
                LOGIC_LOOP = Long.parseLong(args[3]);
            }
        }
        final Dispatcher dispatcher = new RingbufferDispatcher(multithread, "任务执行器", bufferSize);
        long start = System.nanoTime();
        final CountDownLatch countDownLatch = new CountDownLatch(NUM);
        final int coreSize = Runtime.getRuntime().availableProcessors();
        for (int i = 0; i < coreSize; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < NUM / coreSize; i++) {
                        dispatcher.dispatch(Event.wrap(new Runnable() {
                            @Override
                            public void run() {
                                // logic
                                long start = System.nanoTime();
                                for (long i = 0; i < LOGIC_LOOP; i++) {}
                                double elapsed = (System.nanoTime() - start) / 1000.0;
                                COST+=elapsed;
                                countDownLatch.countDown();
                            }
                        }));
                    }
                }
            }).start();
        }
        try {
            countDownLatch.await();
            double elapsed = (System.nanoTime() - start) / 1000000.0;
            long throughput = (long) (NUM / (elapsed / 1000.0));
            System.out.println("throughput: " + throughput + "/sec in " + (long) elapsed + "ms");
            System.out.println("average logic: " + COST / NUM + "us");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        dispatcher.shutdown();
    }
}

 

测试1描述:多生产者模式下单个消费者事件消费能力(无耗时业务逻辑,仅测试事件分发吞吐能力),每种类型操作分别测试3次。

测试1结果:

性能测试笔记-disruptor性能测试">

测试2描述:多生产者模式下单个消费者事件消费能力(有耗时业务逻辑,每个事件平均耗时1.8ms,测试事件分发处理吞吐能力),每种类型操作分别测试3次。

测试2结果:

 

总结:测试1场景中当事件数量超过1000w,其事件分发吞吐能力稳定在300w左右,测试2场景中在两种不同事件数量类型的分发处事过程中,其事件分发处理吞吐能力稳定在540左右。

按照这个测试结果,如果在游戏中引入Disruptor替代传统的BlockQueue处理消息事件,承载数量应该可以提高3倍左右。

时间: 2024-09-13 01:23:27

java中Disruptor性能测试笔记的相关文章

Java中jqGrid 学习笔记整理——进阶篇(二)_java

相关阅读: Java中jqGrid 学习笔记整理--进阶篇(一) 本篇开始正式与后台(java语言)进行数据交互,使用的平台为 JDK:java 1.8.0_71 myEclisp 2015 Stable 2.0 Apache Tomcat-8.0.30 Mysql 5.7 Navicat for mysql 11.2.5(mysql数据库管理工具) 一.数据库部分 1.创建数据库 使用Navicat for mysql创建数据库(使用其他工具或直接使用命令行暂不介绍) 2. 2.创建表 双击打

java中字符串学习笔记

学过编程的都会知道,字符串是常量中的一种,然而java中的String不仅仅是常量,又是类,是一个特殊的类,是不可变和最终类: 1,不可变的String:说到不可变性,就要说java中String的内存分配了,如下图 当运行代码: String str = "abc"; 时,内存分布为 这时候看起来和一个int a = 26;很相似了,StringPool是常量池里面用来存放字符串常量的地方,里面的值不可修改 而如果代码是这样写的: String str = new String(&q

java中的io笔记

Java流在处理上分为字符流和字节流.字符流处理的单元为2个字节的 Unicode 字符,分别操作字符.字符数组或字符串,而字节流处理单元为1个字节,操作字节和字节数组. Java内用Unicode 编码存储字符,字符流处理类负责将外部的其他编码的字符流和java内Unicode字符流之间的转换.而类 InputStreamReader和OutputStreamWriter处理字符流和字节流的转换.字符流(一次可以处理一个缓冲 区)一次操作比字节流(一次一个字节)效率高. ( 一 )以字节为导向

Java中反射性能测试

Java反射效率到底如何,花了点时间,做了一个简单的测试.供大家参考. 测试背景:  1. 测试简单Bean(int,Integer,String)的set方法 2. loop 1亿次 3. 测试代码尽可能避免对象的创建,复发方法的调用,仅仅测试set方法的耗时 测试结果:  场景  本机测试结果(XP,双核,2G) 服务器测试结果(Linux,XEN虚拟机,8核,5.5G) 方法直接调用 235MS 190MS JDK Method调用 29188MS 4633MS JDK Method调用(

java中ormlite 学习笔记

1, 能否直接使用外键id ? # 声明一个外键对象 和 一样普通字段 新建表的时候会出错 , 查数据的时候也会出错 #  http://stackoverflow.com/questions/18988750/ormlite-android-setting-foreign-key-fields-directly # 声明了两个类,分别处理对象和id   2, 对象自己有CRUD ,BaseDaoEnabled   对象的实例方法有对应的crud 只要有继承就行 使用起来如果是new 出来的对象

Java中的StringBuilder性能测试_java

在看KMP算法时,想要简单的统计一下执行时间和性能. 得出的结论是: Java的String的indexOf方法性能最好,其次是KMP算法,其次是传统的BF算法,当然,对比有点牵强,SUN的算法也使用Java来实现.用的看着不像是KMP,还需要详细研究一下. 测试代码如下所示: package com.test.test.kmp; import java.util.Random; public class KMPTest { public static void main(String[] ar

java笔记十:java中的反射

Java中,反射是一种强大的工具.它使您能够创建灵活的代码,这些代码可以在运行时装配,无需在组件之间进行源代表链接.反射允许我们在编写与执行时,使我们的程序代码能够接入装载到JVM中的类的内部信息,而不是源代码中选定的类协作的代码.这使反射成为构建灵活的应用的主要工具.但需注意的是:如果使用不当,反射的成本很高. Java的类反射所需要的类并不多,它们分别是:Field.Constructor.Method.Class.Object,下面我将对这些类做一个简单的说明.Field类:提供有关类或接

java中string 类型的对象间比较的学习笔记

在JAVA 中String 有两种不同的赋值方式 ,"="和new一个新的对象,虽然在输出时显示的内容是一样的,但数据存储的原理是不同的. String a="ab"; String b="ab"; System.out.println(a==b);//true 三句话的执行时这样的:        当把"ab"赋值给a变量时,因为是用"="直接赋值,此时"ab"作为字面量存在栈中,然后

java中对象的浅复制和深复制笔记

在面向对象的语言中,如Java/Python,对象的复制有两种形式:浅复制和深复制 一.浅复制    浅复制只是将原对象的引用备份了一份给新的变量,实际两者指向的是同一个对象.在Python中,字典.列表.元祖等都是对象类型 >>> person=['name',['savings',100.00]] >>> hubby=person[:] >>> wifely=list(person) >>> [id(x) for x in per