Disruptor源码解析六 示例与性能压测

最新推荐文章于 2023-10-23 18:00:10 发布
最新推荐文章于 2023-10-23 18:00:10 发布
阅读量529 收藏 1
点赞数
分类专栏： disruptor 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/destiny4Y/article/details/118103511
版权

目录

前言

perftest结构

压测CASE示例

1V1的blockingQueueCase

1V1的DisruptorCase

blockingQueue VS disruptor多模式对比

单生产者单消费者：

单生产者多消费者(菱形)

单生产者多消费者(串行)

单生产者多消费者(并行)

多生产者多消费者

系列索引

前言

  • 前面几个章节已经分享了disruptor的最主要的几个组件的主要实现和介绍，这里简单分享一个disruptor的具体使用，以及disruptor的性能对比blockingQueue在各种场景下的性能提升有多大。
  • 本节的主要代码分享来自disruptor代码的perftest目录，是官方提供的压测case实现。
  • 一般场景下，我们将blockQueue替换为disruptor，会得到极大的吞吐量提升。

perftest结构

上图中未展开的都是，一些实现类或者配置目录，展开的都是具体的压测CASE实现

  • offheap    ----disruptor堆内堆外内存性能对比测试目录
  • queue      ----基于blockingQueue实现的生产消费CASE, 用于和disruptor的实现对比
  • raw   ----只生产不消费(或者消费不处理)的处理记录
  • support   ----压测case用到的一些配置实现类，主要是event，生产者，消费者的相关实现
  • sequenced  ---基于disruptor的相关实现的生产消费CASE，与queue目录中的case对比
  • translator  ----生产者translator的相关压测
  • workhandler   workPool模式的消费者的相关性能压测
  • AbstractPerfTestDisruptor  disruptor压测case集成的基类
  • AbstractPerfTestQueue   blockingQueuey压测case集成的基类

压测CASE示例

perftest的重点应该在blockingQueue与disruptor的吞吐比较，性能指标计算方式为吞吐量，公式：

qps = 处理的消息数 / 处理总时间

在每个压测CASE上，基本都有生产消费的结构图，展示了本case的生产消费结构。

1V1的blockingQueueCase

blockQueue的一个最简单实现(单生产者单消费者)：

注释中即说明了本个case的实现。P1(生产者) -> Q1(阻塞队列) -> EP1(消费者)

/**
 * <pre>
 * UniCast a series of items between 1 publisher and 1 event processor.
 *
 * +----+    +-----+
 * | P1 |--->| EP1 |
 * +----+    +-----+
 *
 * Queue Based:
 * ============
 *
 *        put      take
 * +----+    +====+    +-----+
 * | P1 |--->| Q1 |<---| EP1 |
 * +----+    +====+    +-----+
 *
 * P1  - Publisher 1
 * Q1  - Queue 1
 * EP1 - EventProcessor 1
 *
 * </pre>
 */
public final class OneToOneQueueThroughputTest extends AbstractPerfTestQueue
{
    // BlockingQueue队列大小
    private static final int BUFFER_SIZE = 1024 * 64;
    // 生产次数
    private static final long ITERATIONS = 1000L * 1000L * 10L;
    // 消费者线程池
    private final ExecutorService executor = Executors.newSingleThreadExecutor(DaemonThreadFactory.INSTANCE);
    private final long expectedResult = ITERATIONS * 3L;

    ///

    // 阻塞队列
    private final BlockingQueue<Long> blockingQueue = new LinkedBlockingQueue<Long>(BUFFER_SIZE);
    // 消费者，内部实现就是阻塞的take方法，当都处理完之后(处理次数等于ITERATIONS - 1)，通过countDownLatch，来通知处理完毕
    private final ValueAdditionQueueProcessor queueProcessor =
        new ValueAdditionQueueProcessor(blockingQueue, ITERATIONS - 1);

    ///

    @Override
    protected int getRequiredProcessorCount()
    {
        return 2;
    }

    @Override
    protected long runQueuePass() throws InterruptedException
    {
        final CountDownLatch latch = new CountDownLatch(1);
        queueProcessor.reset(latch);
        Future<?> future = executor.submit(queueProcessor);
        long start = System.currentTimeMillis();

        // 这里就是生产者
        for (long i = 0; i < ITERATIONS; i++)
        {
            blockingQueue.put(3L);
        }

        // 等待消费者消费完
        latch.await();
        // 计算吞吐吞吐量
        long opsPerSecond = (ITERATIONS * 1000L) / (System.currentTimeMillis() - start);
        // 关闭消费者
        queueProcessor.halt();
        // 关闭线程池
        future.cancel(true);

        PerfTestUtil.failIf(expectedResult, 0);

        return opsPerSecond;
    }

    public static void main(String[] args) throws Exception
    {
        OneToOneQueueThroughputTest test = new OneToOneQueueThroughputTest();
        test.testImplementations();
    }
}

1V1的DisruptorCase

disruptor的一个最简单实现(单生产者单消费者)：

注释中即说明了本个case的实现。P1(生产者) -> RB(ringBuffer) -> SB(SequenceBarrier) -> EP1(消费者)

/**
 * <pre>
 * UniCast a series of items between 1 publisher and 1 event processor.
 *
 * +----+    +-----+
 * | P1 |--->| EP1 |
 * +----+    +-----+
 *
 * Disruptor:
 * ==========
 *              track to prevent wrap
 *              +------------------+
 *              |                  |
 *              |                  v
 * +----+    +====+    +====+   +-----+
 * | P1 |--->| RB |<---| SB |   | EP1 |
 * +----+    +====+    +====+   +-----+
 *      claim      get    ^        |
 *                        |        |
 *                        +--------+
 *                          waitFor
 *
 * P1  - Publisher 1
 * RB  - RingBuffer
 * SB  - SequenceBarrier
 * EP1 - EventProcessor 1
 *
 * </pre>
 */
public final class OneToOneSequencedThroughputTest extends AbstractPerfTestDisruptor
{
    // ringbuffer大小
    private static final int BUFFER_SIZE = 1024 * 64;
    // 生产次数
    private static final long ITERATIONS = 1000L * 1000L * 100L;
    // 消费者线程池
    private final ExecutorService executor = Executors.newSingleThreadExecutor(DaemonThreadFactory.INSTANCE);
    private final long expectedResult = PerfTestUtil.accumulatedAddition(ITERATIONS);

    ///

    // 下面是disruptor的一些组件
    // ringbuffer构造, yield等待策略
    private final RingBuffer<ValueEvent> ringBuffer =
        createSingleProducer(ValueEvent.EVENT_FACTORY, BUFFER_SIZE, new YieldingWaitStrategy());
    // sequenceBarrier构造, 默认依赖的是生产者
    private final SequenceBarrier sequenceBarrier = ringBuffer.newBarrier();
    // 消费者处理器实现， 内部就是一个一个取出，处理
    private final ValueAdditionEventHandler handler = new ValueAdditionEventHandler();
    // 真实的消费者，代理了上面的消费者处理器
    private final BatchEventProcessor<ValueEvent> batchEventProcessor =
        new BatchEventProcessor<ValueEvent>(ringBuffer, sequenceBarrier, handler);

    {
        // 生产者需要依赖最后一个消费者的位置来看能不能生产
        ringBuffer.addGatingSequences(batchEventProcessor.getSequence());
    }

    ///

    @Override
    protected int getRequiredProcessorCount()
    {
        return 2;
    }

    @Override
    protected long runDisruptorPass() throws InterruptedException
    {
        final CountDownLatch latch = new CountDownLatch(1);
        long expectedCount = batchEventProcessor.getSequence().get() + ITERATIONS;
        handler.reset(latch, expectedCount);
        executor.submit(batchEventProcessor);
        long start = System.currentTimeMillis();

        final RingBuffer<ValueEvent> rb = ringBuffer;

        // 开始生产
        for (long i = 0; i < ITERATIONS; i++)
        {
            long next = rb.next();
            rb.get(next).setValue(i);
            rb.publish(next);
        }

        // 等待消费完毕
        latch.await();
        // 计算吞吐量
        long opsPerSecond = (ITERATIONS * 1000L) / (System.currentTimeMillis() - start);
        // 消费者退出
        waitForEventProcessorSequence(expectedCount);
        batchEventProcessor.halt();

        PerfTestUtil.failIfNot(expectedResult, handler.getValue());

        return opsPerSecond;
    }

    private void waitForEventProcessorSequence(long expectedCount) throws InterruptedException
    {
        while (batchEventProcessor.getSequence().get() != expectedCount)
        {
            Thread.sleep(1);
        }
    }

    public static void main(String[] args) throws Exception
    {
        OneToOneSequencedThroughputTest test = new OneToOneSequencedThroughputTest();
        test.testImplementations();
    }
}

blockingQueue VS disruptor多模式对比

下面抛出的qps都是在本地mac上运行官方perftest代码跑出来的，本地配置为：

单生产者单消费者：

 * +----+    +-----+
 * | P1 |--->| EP1 |
 * +----+    +-----+
 *
 * Queue Based:
 * ============
 *
 *        put      take
 * +----+    +====+    +-----+
 * | P1 |--->| Q1 |<---| EP1 |
 * +----+    +====+    +-----+
 *
 * P1  - Publisher 1
 * Q1  - Queue 1
 * EP1 - EventProcessor 1
 * ------------------------------------------
 * Disruptor:
 * ==========
 *              track to prevent wrap
 *              +------------------+
 *              |                  |
 *              |                  v
 * +----+    +====+    +====+   +-----+
 * | P1 |--->| RB |<---| SB |   | EP1 |
 * +----+    +====+    +====+   +-----+
 *      claim      get    ^        |
 *                        |        |
 *                        +--------+
 *                          waitFor
 *
 * P1  - Publisher 1
 * RB  - RingBuffer
 * SB  - SequenceBarrier
 * EP1 - EventProcessor 1

BlockingQueue的Case:
OneToOneQueueThroughputTest
        blockingQueue普通单生产者单消费者，生产者依次放入，消费者通过queue.take取数据,消费者执行的操作是加和
        3,872,966 ops/sec
OneToOneQueueBatchedThroughputTest
        blockingQueue单生产者单消费者，生产者依次放入，消费者批量消费数据，通过queue.drain取数据,消费者执行的操作是加和
        7,824,726 ops/sec


Disruptor的Case：
OneToOneSequencedThroughputTest
        disruptor普通的单生产者单消费者，生产者依次放入，消费者通过sequenceBarrier.waitFor获取,批量消费,消费者执行的操作是加和
        169,491,525 ops/sec
OneToOneSequencedBatchThroughputTest
        disruptor普通的单生产者单消费者，生产者批量放入，消费者通过sequenceBarrier.waitFor获取，批量消费,消费者执行的操作是加和
        330,250,990 ops/sec
OneToOneSequencedLongArrayThroughputTest
        disruptor普通的单生产者单消费者，生产者依次放入，消费者通过sequenceBarrier.waitFor获取，批量消费，消费者内部处理的事消除了伪共享的变量,消费者执行的操作是加和
        1,375,419,744 ops/sec

单生产者多消费者(菱形)

*           +-----+
*    +----->| EP1 |------+
*    |      +-----+      |
*    |                   v
* +----+              +-----+
* | P1 |              | EP3 |
* +----+              +-----+
*    |                   ^
*    |      +-----+      |
*    +----->| EP2 |------+
*           +-----+
*
*
* Queue Based:
* ============
*                 take       put
*     put   +====+    +-----+    +====+  take
*    +----->| Q1 |<---| EP1 |--->| Q3 |<------+
*    |      +====+    +-----+    +====+       |
*    |                                        |
* +----+    +====+    +-----+    +====+    +-----+
* | P1 |--->| Q2 |<---| EP2 |--->| Q4 |<---| EP3 |
* +----+    +====+    +-----+    +====+    +-----+
*
* P1  - Publisher 1
* Q1  - Queue 1
* Q2  - Queue 2
* Q3  - Queue 3
* Q4  - Queue 4
* EP1 - EventProcessor 1
* EP2 - EventProcessor 2
* EP3 - EventProcessor 3
*
*
* Disruptor:
* ==========
*                    track to prevent wrap
*              +-------------------------------+
*              |                               |
*              |                               v
* +----+    +====+               +=====+    +-----+
* | P1 |--->| RB |<--------------| SB2 |<---| EP3 |
* +----+    +====+               +=====+    +-----+
*      claim   ^  get               |   waitFor
*              |                    |
*           +=====+    +-----+      |
*           | SB1 |<---| EP1 |<-----+
*           +=====+    +-----+      |
*              ^                    |
*              |       +-----+      |
*              +-------| EP2 |<-----+
*             waitFor  +-----+
*
* P1  - Publisher 1
* RB  - RingBuffer
* SB1 - SequenceBarrier 1
* EP1 - EventProcessor 1
* EP2 - EventProcessor 2
* SB2 - SequenceBarrier 2
* EP3 - EventProcessor 3

BlockingQueue的Case:
OneToThreeDiamondQueueThroughputTest
        blockingQueue单生产者，后接3个菱形消费者，共4个blockingQueue
        1,700,535 ops/sec

Disruptor的Case:
OneToThreeDiamondSequencedThroughputTest
        disruptor单生产者，后接3个菱形消费者，一个ringbuffer解决
        142,045,454 ops/sec

单生产者多消费者(串行)

*
* +----+    +-----+    +-----+    +-----+
* | P1 |--->| EP1 |--->| EP2 |--->| EP3 |
* +----+    +-----+    +-----+    +-----+
*
*
* Queue Based:
* ============
*
*        put      take        put      take        put      take
* +----+    +====+    +-----+    +====+    +-----+    +====+    +-----+
* | P1 |--->| Q1 |<---| EP1 |--->| Q2 |<---| EP2 |--->| Q3 |<---| EP3 |
* +----+    +====+    +-----+    +====+    +-----+    +====+    +-----+
*
* P1  - Publisher 1
* Q1  - Queue 1
* EP1 - EventProcessor 1
* Q2  - Queue 2
* EP2 - EventProcessor 2
* Q3  - Queue 3
* EP3 - EventProcessor 3
*------------------------------------------------------
* Disruptor:
* ==========
*                           track to prevent wrap
*              +----------------------------------------------------------------+
*              |                                                                |
*              |                                                                v
* +----+    +====+    +=====+    +-----+    +=====+    +-----+    +=====+    +-----+
* | P1 |--->| RB |    | SB1 |<---| EP1 |<---| SB2 |<---| EP2 |<---| SB3 |<---| EP3 |
* +----+    +====+    +=====+    +-----+    +=====+    +-----+    +=====+    +-----+
*      claim   ^  get    |   waitFor           |   waitFor           |  waitFor
*              |         |                     |                     |
*              +---------+---------------------+---------------------+
*     
* P1  - Publisher 1
* RB  - RingBuffer
* SB1 - SequenceBarrier 1
* EP1 - EventProcessor 1
* SB2 - SequenceBarrier 2
* EP2 - EventProcessor 2
* SB3 - SequenceBarrier 3
* EP3 - EventProcessor 3

BlockingQueue的Case:
OneToThreePipelineQueueThroughputTest
        blockingQueue，单生产者后接3个串行消费者，共3个blockngQueue
        2,195,389 ops/sec

disruptor的Case:
OneToThreePipelineSequencedThroughputTest
        disruptor，单生产者后接3个串行消费者，一个ringbuffer
        121,065,375 ops/sec

单生产者多消费者(并行)

 *           +-----+
 *    +----->| EP1 |
 *    |      +-----+
 *    |
 * +----+    +-----+
 * | P1 |--->| EP2 |
 * +----+    +-----+
 *    |
 *    |      +-----+
 *    +----->| EP3 |
 *           +-----+
 *
 *
 * Queue Based:
 * ============
 *                 take
 *   put     +====+    +-----+
 *    +----->| Q1 |<---| EP1 |
 *    |      +====+    +-----+
 *    |
 * +----+    +====+    +-----+
 * | P1 |--->| Q2 |<---| EP2 |
 * +----+    +====+    +-----+
 *    |
 *    |      +====+    +-----+
 *    +----->| Q3 |<---| EP3 |
 *           +====+    +-----+
 *
 * P1  - Publisher 1
 * Q1  - Queue 1
 * Q2  - Queue 2
 * Q3  - Queue 3
 * EP1 - EventProcessor 1
 * EP2 - EventProcessor 2
 * EP3 - EventProcessor 3
 * -------------------------------------------------------------
 * Disruptor:
 * ==========
 *                             track to prevent wrap
 *             +--------------------+----------+----------+
 *             |                    |          |          |
 *             |                    v          v          v
 * +----+    +====+    +====+    +-----+    +-----+    +-----+
 * | P1 |--->| RB |<---| SB |    | EP1 |    | EP2 |    | EP3 |
 * +----+    +====+    +====+    +-----+    +-----+    +-----+
 *      claim      get    ^         |          |          |
 *                        |         |          |          |
 *                        +---------+----------+----------+
 *                                      waitFor
 *
 * P1  - Publisher 1
 * RB  - RingBuffer
 * SB  - SequenceBarrier
 * EP1 - EventProcessor 1
 * EP2 - EventProcessor 2
 * EP3 - EventProcessor 3

BlockingQueue的Case:
OneToThreeQueueThroughputTest
        单生产者，多消费者，每个消费者一个blockingQueue, 执行的操作是加减操作
        1,257,861 ops/sec

Disruptor的Case:
OneToThreeSequencedThroughputTest
        单生产者，多消费者，一个ringBuffer，每个消费者依赖同一个SequenceBarrier, 执行的操作是加减操作
        139,860,139 ops/sec

多生产者单消费者

 * +----+
 * | P1 |------+
 * +----+      |
 *             v
 * +----+    +-----+
 * | P1 |--->| EP1 |
 * +----+    +-----+
 *             ^
 * +----+      |
 * | P3 |------+
 * +----+
 *
 *
 * Queue Based:
 * ============
 *
 * +----+  put
 * | P1 |------+
 * +----+      |
 *             v   take
 * +----+    +====+    +-----+
 * | P2 |--->| Q1 |<---| EP1 |
 * +----+    +====+    +-----+
 *             ^
 * +----+      |
 * | P3 |------+
 * +----+
 *
 * P1  - Publisher 1
 * P2  - Publisher 2
 * P3  - Publisher 3
 * Q1  - Queue 1
 * EP1 - EventProcessor 1
 
 *-----------------------------------------------------------
 * Disruptor1:
 * ==========
 *             track to prevent wrap
 *             +--------------------+
 *             |                    |
 *             |                    v
 * +----+    +====+    +====+    +-----+
 * | P1 |--->| RB |<---| SB |    | EP1 |
 * +----+    +====+    +====+    +-----+
 *             ^   get    ^         |
 * +----+      |          |         |
 * | P2 |------+          +---------+
 * +----+      |            waitFor
 *             |
 * +----+      |
 * | P3 |------+
 * +----+
 *
 * P1  - Publisher 1
 * P2  - Publisher 2
 * P3  - Publisher 3
 * RB  - RingBuffer
 * SB  - SequenceBarrier
 * EP1 - EventProcessor 1

 *-----------------------------------------------------------
 * Disruptor2:
 * ==========
 *             track to prevent wrap
 *             +--------------------+
 *             |                    |
 *             |                    |
 * +----+    +====+    +====+       |
 * | P1 |--->| RB |--->| SB |--+    |
 * +----+    +====+    +====+  |    |
 *                             |    v
 * +----+    +====+    +====+  | +----+
 * | P2 |--->| RB |--->| SB |--+>| EP |
 * +----+    +====+    +====+  | +----+
 *                             |
 * +----+    +====+    +====+  |
 * | P3 |--->| RB |--->| SB |--+
 * +----+    +====+    +====+
 *
 * P1 - Publisher 1
 * P2 - Publisher 2
 * P3 - Publisher 3
 * RB - RingBuffer
 * SB - SequenceBarrier
 * EP - EventProcessor

BlockingQueue的Case:
ThreeToOneQueueThroughputTest
        多生产者，单消费者，一个blockingQueue，依次消费，执行加和操作
        6,103,143 ops/sec

Disruptor的Case:
ThreeToOneSequencedThroughputTest
        多生产者，单消费者，一个ringBuffer，每个生产者依次生产,依次批量消费，执行加和操作
        8,389,261 ops/sec
ThreeToOneSequencedThroughputTest
        多生产者，单消费者，一个ringBuffer，每个生产者批量生产，依次批量消费，执行加和操作
        102,774,922 ops/sec
ThreeToThreeSequencedThroughputTest
        多生产者，单消费者，每个生产者一个ringBuffer，每个生产者依次生产，依次批量消费，执行加和操作
        490,018,148 ops/sec

destiny4Y
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
disruptor-3.2.1源码带jar包20140321
03-21
最快的java并发框架disruptor已经将编译好的jar包集成在里面过阵子写个完整版本的示例再上传，本人其他资源也不错请大家多多下载
Disruptor源码解析五 消费者的具体实现
destiny4Y的专栏
05-28 716
前言 前一篇章节已经具体描述了消费者的串联方式，这里主要讲解一下消费者的具体实现。
JAVA高性能有界内存队列－Disruptor 简介及使用示例
bossfriday - 个人博客
03-15 1657
Disruptor是一个高性能的有界内存队列，它在 Apache Storm、Camel、Log4j 2 等很多知名项目中都有广泛应用。之所以如此受青睐，主要还是因为它的性能表现非常优秀。它比 Java 中另外一个非常常用的内存消息队列 ArrayBlockingQueue（ABS）的性能，要高一个数量级，可以算得上是最快的内存消息队列了。它还因此获得过 Oracle 官方的 Duke 大奖。
disruptor第三弹(手撕第五章)
xiao__miao的博客
09-24 200
前言：现在我们创建一个拥有消费者和生产者指针的派生类。进行两端的维护 这一章的内容比较多，各位仔细看代码了 public interface WaitStrategy { /** * 消费者的阻塞方法 * @param sequence * @param cursor */ long waitFor(long sequence, S...
高性能高并发队列-Disruptor
weixin_34238642的博客
12-09 661
为什么80%的码农都做不了架构师？>>> ...
spring与disruptor集成的简单示例
08-27
本篇文章主要介绍了spring与disruptor集成的简单示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SourceAnalysis_Disruptor:Disruptor原始码解析-源码解析
03-24
SourceAnalysis_Disruptor Disruptor原始码解析
Disruptor示例
10-19
Martin Fowler在自己网站上写了一篇LMAX架构的文章，在文章中他...Disruptor是一个高性能的异步处理框架，或者可以认为是最快的消息框架（轻量的JMS），也可以认为是一个观察者模式的实现，或者事件监听模式的实现。
Okra:Netty和Disruptor的高性能游戏服务器框架
05-08
Okra是一个简单的使用JAVA开发的高性能，高扩展，高并发，低延迟的服务器框架。 主要目的是帮助中小团队快速开发实现网络游戏服务端。 本项目包含完整的MMORPG等游戏服务器的DEMO. Dependencies： JDK 1.8 : 框架...
disruptor-3.4.4.jar disruptor 3.4.4 jar 官方github下载
05-31
disruptor-3.4.4.jar 官方github下载 亲测可用，大家赶紧下载吧 后续再补充其他常用jar（但不好下载的）
LMAX disruptor jar包+Demo+Api+src源码 disruptor-3.0.1.jar
06-04
LMAX Disruptor 最新版本 源码+API+驱动包
并发框架Disruptor
11-21
Java并发框架Disruptor，里面采取环形缓存结构，速度更快,适用于生产者消费者模式
disruptor架构三 使用场景 使用WorkHandler和BatchEventProcessor辅助创建消费者
weixin_34254823的博客
10-12 2084
在helloWorld的实例中，我们创建Disruptor实例，然后调用getRingBuffer方法去获取RingBuffer，其实在很多时候，我们可以直接使用RingBuffer，以及其他的API操作。我们一起熟悉下示例： 使用EventProcessor消息处理器。 BatchEventProcessor 多线程并发执行,不同线程执行不同是不同的event EventProce...
Disruptor - 深入理解高性能异步处理框架
最新发布
花&败
10-23 403
在并发编程的世界中，对效率的追求从未停止过。我们尝试用各种方式来提高程序的执行效率，包括使用更高级的并发控制结构，如锁和线程池，以及采用更先进的并发设计模式。然而，有一种工具在许多高性能系统中得到了广泛的应用，那就是Disruptor。Disruptor是一个高性能的异步处理框架，它利用了Ring Buffer、CAS等高效的并发策略，使得在处理高并发、低延迟的需求时，表现出了惊人的性能。我们来看一张图：这是一张展示了Disruptor和性能对比的直方图，你可以明显地看到Disruptor的优越性能。
Disruptor测试结果运算1亿次，耗时5503ms，吞吐量18171000/s，于是我扒开了Disruptor高性能的外衣
博学谷狂野架构师的博客
09-20 558
​ 为了解决计算机系统中主内存与 CPU 之间运行速度差问题，会在 CPU 与主内存之间 添加一级或者多级高速缓冲存储器( Cache)。这个 Cache 一般是被集成到 CPU 内部的， 所以也叫 CPU Cache，如图所示是两级 Cache 结构。​ Cache内部是按行存储的，其中每一行称为一个cache line，由很多个 Cache line 组成的，Cache line 是 cache 和 RAM 交换数据的最小单位，cache行的大小一般为2的幂次数字节，通常为 64 Byte。
java+workhandler,disruptor架构三 使用场景 使用WorkHandler和BatchEventProcessor辅助创建消费者...
weixin_31304599的博客
03-21 1023
在helloWorld的实例中，我们创建Disruptor实例，然后调用getRingBuffer方法去获取RingBuffer，其实在很多时候，我们可以直接使用RingBuffer，以及其他的API操作。我们一起熟悉下示例：使用EventProcessor消息处理器。BatchEventProcessor 多线程并发执行,不同线程执行不同是不同的eventEventProcessor有3个实现类...
性能测试中Disruptor框架shutdown失效的问题分享
主要分享测试的学习资源，帮助快速了解测试行业，帮助想转行、进阶、小白成长为高级测试工程师。
03-05 2915
在基于Disruptor开发新的性能测试QPS模型时候，中间遇到了很多问题，踩了很多坑。今天就分享一个比较典型的问题：shutdown失效。 问题在于这么优秀的一个框架，怎么可能会存在这么明显的BUG？ 经过查阅资料，还真特么存在，只不过在极少数使用场景下会发生，刚好FunTester性能测试框架设计中就属于这个场景。下面听说娓娓道来。 首先我是把每一个消费者线程都当做性能测试线程使用，此为前提。下面是两个因此带来的设定： Disruptor框架的消费者线程或者消费者线程数组数需要在Disruptor启.
Disruptor面试宝典
热门推荐
识时务者的个人博客
04-07 14万+
Disruptor面试题 1.什么是 Disruptor？它有哪些特点？ 2.Disruptor 如何实现无锁并发？它的核心原理是什么？ 3.Disruptor 的优缺点是什么？ 4.Disruptor 中的 RingBuffer 是什么？有哪些作用？ 5.Disruptor 中的 Sequence 是什么？有哪些作用？ 6.Disruptor 中的 EventProcessor 是什么？有哪些作用？
disruptor笔记之一：快速入门
程序员欣宸的博客
05-24 3064
由浅入深，通过实战掌握高性能队列disruptor
disruptor源码
06-13
定义和认定标准：分析工伤定义和认定标准的意义和作用，以及如何制Disruptor的源代码是开放的，可以在GitHub上获得。Disruptor的GitHub地址是：https://github定和修订认定标准，以适应不同的社会和经济环境。 b. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值