disruptor原理详解

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

一、Disruptor
1、Disruptor基本原理

在现在的CPU中，每次从主内存读取数据到L3级缓存的大小是64k，也叫做cache line。
CPU找数据的过程：CPU->L1->L2->L3->主内存；CPU更新数据的过程也是如此。
CPU从内存加载数据的过程：L3->L2->L1->CPU
disruptor开源并发框架（RingBuffer:缓存一致性协议)
<dependency>
    <groupId>com.lmax</groupId>
    <artifactId>disruptor</artifactId>
    <version>3.4.2</version>
</dependency>

在多线程开发中，我们常常遇到这样一种场景：一些线程接受用户请求，另外一些线程处理这些请求。比如日志处理中的日志输入和告警。这种典型的生产者消费者场景十分常见，而生产者消费者模式的核心就是阻塞队列。由于阻塞队列会涉及大量的锁竞争和线程阻塞，都是非常耗费CPU的操作，因此阻塞队列的性能好坏能够在很大程度上决定上层应用的性能瓶颈。

JAVA中用BlockingQueue这个接口来描述阻塞队列，有数组实现的有界阻塞队列为 ArrayBlockingQueue，用链表实现的无界阻塞队列为LinkedBlockingQueue，除此之外还有优先级阻塞队列 PriorityBlockingQueue，这些阻塞队列除了自身特有逻辑外，都采用基于悲观锁的并发控制。这样的并发机制会有严重的锁冲突，大大影响并发性能。Disruptor满足了我们的要求。

锁是用来做并发最简单的方式，当然其代价也是最高的。内核态的锁的时候需要操作系统进行一次上下文切换，等待锁的线程会被挂起直至锁释放。

使用了Ringbuffer，内存屏障，乐观并发控制等众多优化手段后，Disrupter的阻塞队列与传统的阻塞队列相比有超过10倍的吞吐率。

Disruptor的主要设计思想是无锁的高并发，在设计上采用内存屏障的机制和CAS操作实现此思想。主流的并发程序 都离不开锁对资源的管控，或者尽量避开锁的使用。
其主要的实现原理总结有如下三点：

  • 采用消费者-生产者模型进行读写的分离。
  • 用循环缓存（实际是一个环形循环队列）实现了数据的暂存和读写速度的匹配。
  • 用内存屏障加序列号的方式实现了无锁的并发机制(Load-Store)。

为什么Disruptor的速度这么快？

我们知道Disruptor速度很快，但是为什么呢？
Disruptor没有使用很影响性能锁 。取而代之的是，在需要确保操作是线程安全的（特别是，在多生产者的环境下，更新下一个可用的序列号）地方，我们使用CAS（Compare And Swap/Set）操作。这是一个CPU级别的指令，它的工作方式有点像乐观锁——CPU去更新一个值，但如果想改的值不是原来的值，操作就失败，反之则去更新这个值。

说句题外话，Java中AtomicInteger也使用了CAS操作来保证原子性。在并发控制中，CAS操作是十分重要的。

CAS操作是CPU级别的指令，在Java中CAS操作在Unsafe类中（Unsafe，见名知意，这个类是不安全的，不建议在实际开发的时候使用）。关于CAS操作的原理网上有很多，在此不过多说明了。

另一个重要的因素是Disruptor消除了伪共享。 下面引用网上的一段话，来解释下什么是伪共享。

缓存系统中是以缓存行（cache line）为单位存储的。缓存行是 2 的整数幂个连续字节，一般为 32-256 个字节。最常见的缓存行大小是 64个字节。

当多线程修改互相独立的变量时，如果这些变量共享同一个缓存行，就会无意中影响彼此的性能，这就是伪共享，即缓存一致性协议。缓存行上的写竞争是运行在 SMP 系统中并行线程实现可伸缩性最重要的限制因素。有人将伪共享描述成无声的性能杀手，因为从代码中很难看清楚是否会出现伪共享。

第三个原因是Disruptor采用了RingBuffer。Ring Buffer 是一个数组，它比链表要快，而且有一个容易预测的访问模式，数据可以在硬件层面预加载到高速缓存，极大的提高了数据访问的速度。
RingBuffer可以预先分配内存，并且保持数组元素永远有效。这意味着内存垃圾收集（GC）在这种情况下几乎什么也不用做。

2、Disuptor基本概念

  • RingBuffer：Ringbuffer是一个环形缓冲区，是Disruptor的核心。
  • Sequencer：序号管理器，使消费者和生产者之前快速正确地传输数据。
  • Sequence：RingBuffer中每个数据的序号，用于跟踪ringbuffer中任务的变化和消费者的消费情况。
  • SequenceBarrier：序号栅栏，管理和协调生产者的游标序号和各个消费者的序号，确保生产者不会覆盖消费者未来得及处理的消息，确保存在依赖的消费者之间能够按照正确的顺序处理。
  • Event：生产者和消费者之间进行交换的数据称为事件。
  • EventProcessor：事件处理器，监听RingBuffer的事件，并消费可用事件，从RingBuffer读取的事件会交由实际的生产者实现类来消费；它会一直侦听下一个可用的序号，直到该序号对应的事件已经准备好。
  • EventHandler：业务处理器，是实际消费者的接口，完成具体的业务逻辑实现，第三方实现该接口；代表着消费者。
  • Producer：生产者接口，第三方线程充当该角色，producer向RingBuffer写入事件

3、环形数组RingBuffer

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述 

二、Disruptor 与ArrayBlockingQueue的性能比对

1、测试结果
经测试发现：

1、容量大小 与 消费者的消费速度 与整个耗时 成正比。
2、Disruptor的性能在高并发、高数据规模（bufferSize 要大些）时表现更突出。
3、Disruptor与LinkedBlockingQueue（比ArrayBlockingQueue性能好些）比对而言，当bufferSize大些的时候，也有优势。


与等待策略说明进行比较：

 由上面的数据可以看出：

BlockingWaitStrategy和TimeoutBlockingWaitStrategy的效率差不多，都是应用在CPU资源紧缺，吞吐量和延迟并不重要的场景，其他几个等待策略略微处理事件略微有点大，是将近前两种的两倍。Disruptor在不配置策略的时候，默认使用BlockingWaitStrategy；在不配置单个生产者和多个生产者的时候，默认使用多个生产者。即使用ProducerType.MULTI。

2、在pom文件中引入disruptor

<dependency>
<groupId>com.lmax</groupId>
<artifactId>disruptor</artifactId>
<version>3.4.2</version>
</dependency>

3、测试入口

import java.time.Instant;
import java.time.format.DateTimeFormatter;

/**
 * 创建时间：2021年5月19日 13:38:07
 * 创建作者：admin
 * 当前版本：v1.0
 * 基本功能：比对测试
 */
public class CompareTest {
    public static int THREAD = 256;//2 << 5; // 线程数量 5 8  64 128 256
    public static int PER = 65536 ;//2 << 10; // 单个线程生产数量 65536
    public static int TOTAL_COUNT = THREAD * PER; // 数据总数量
    public static int SIZE =1048576; // 最大容量 32 128 512 1024 2048 1048576

    public static void main(String[] args) {
        println("线程数：" + THREAD + " 单线程生产量: " + PER + " 容量：" + SIZE + " 数据总量：" + TOTAL_COUNT);
        //分开执行
        //new Thread(() -> ArrayBlockingQueueTest.execute()).start();
        new Thread(() -> DisruptorTest.execute()).start();
    }

    public static void println(String msg) {
        System.out.println(DateTimeFormatter.ISO_INSTANT.format(Instant.now()) + "  " + msg);
    }
}


4、ArrayBlockingQueue 测试用例

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
/**
 * 创建时间：2021年5月19日 13:38:07
 * 创建作者：admin
 * 当前版本：v1.0
 * 基本功能：ArrayBlockingQueue Test
 */
public class ArrayBlockingQueueTest {

    public static void execute() {
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<String>(CompareTest.SIZE);

        AtomicBoolean endP = new AtomicBoolean(false);
        AtomicBoolean endC = new AtomicBoolean(false);
        long startTime = System.currentTimeMillis();
        AtomicLong count = new AtomicLong(0);
        for (int i = 0; i < CompareTest.THREAD; i++) {
            final int m = i;
            new Thread(() -> {
                for (int j = 0; j < CompareTest.PER; j++) {
                    try {
                        queue.put("i" + m + "j" + j); // 队列不够，等待生产
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (count.incrementAndGet() == CompareTest.TOTAL_COUNT) {
                        CompareTest.println("ArrayBlockingQueue 生产耗时：" + (System.currentTimeMillis() - startTime));
                        endP.set(true);
                    }
                }
            }).start();
        }

        new Thread(() -> {
            AtomicLong consumerCount = new AtomicLong(0);
            while (true) {
                try {
                    queue.take(); // 直到消费完所有信息
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (consumerCount.incrementAndGet() == CompareTest.TOTAL_COUNT) {
                    break;
                }
            }
            CompareTest.println("处理count：" + consumerCount.get() + "  ArrayBlockingQueue 消费耗时："
                    + (System.currentTimeMillis() - startTime));
            endC.set(true);
        }).start();

        while (!(endC.get() && endP.get())) {}

        CompareTest.println("ArrayBlockingQueue 总耗时：" + (System.currentTimeMillis() - startTime));

    }
}


5、Disruptor 测试用例

import com.lmax.disruptor.*;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.dsl.ProducerType;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
/**
 * 创建时间：2021年5月19日 13:38:07
 * 创建作者：admin
 * 当前版本：v1.0
 * 基本功能：disruptor测试线程
 */
public class DisruptorTest {
    public static void execute() {
        Disruptor<DataEvent> disruptor = new Disruptor<DataEvent>(
                new DataEventFactory(),     //创建事件（数据）工厂
                CompareTest.SIZE,           //环形数组大小，即创建ringBuffer大小，一定是2的N次
                new ThreadFactory() {       //创建一个线程工厂 提供线程来触发Consumer的事件处理
                    @Override
                    public Thread newThread(Runnable eventProcessor) {
                        // 对事件处理总线的封装
                        CompareTest.println("EventProcessor wrapper");
                        Thread thread = new Thread(eventProcessor);
                        thread.setName("EventProcessorWrapper");
                        return thread;
                    }
                },
                /**
                 * 1、ProducerType.SINGLE 表示单个生产者
                 * 2、ProducerType.MULTI 表示多个生产者
                 */
                ProducerType.MULTI,
                /**
                 *  消费者的等待策略
                 *          名称                    措施                     适用场景
                 * BlockingWaitStrategy            加锁                     CPU资源紧缺，吞吐量和延迟 并不重要的场景
                 * BusySpinWaitStrategy            自旋                     通过不断重试，减少切换线程导致的系统调用，而降低延迟。推荐在线程绑定到固定的CPU的场景下使用
                 * PhasedBackoffWaitStrategy    自旋 yield 自定义策略     CPU资源紧缺，吞吐量和延迟 并不重要的场景
                 * SleepingWaitStrategy            自旋 yield sleep         性能和CPU资源之间有很好的折中。延迟不均匀
                 * TimeoutBlockingWaitStrategy 加锁，有超时限制           CPU资源紧缺，吞吐量和延迟 并不重要的场景
                 * YieldingWaitStrategy            自旋 yield 自旋            性能和CPU资源之间有很好的折中。延迟比较均匀
                 * 这里需要降低延迟，所以选择 BusySpinWaitStrategy
                 */
                new BlockingWaitStrategy());
                //new TimeoutBlockingWaitStrategy(2000L, TimeUnit.SECONDS));
                //new PhasedBackoffWaitStrategy(1000L , 1000L , TimeUnit.SECONDS , new SleepingWaitStrategy()));
        CompareTest.println("测试策略：BusySpinWaitStrategy");
        /**
         * 创建EventProcessors<Runnable>.
         * 子过程Disruptor.checkNotStarted()事件处理handler必须在启动之前绑定.
         */
        disruptor.handleEventsWith(new DataEventHandler());

        disruptor.start();
        CompareTest.println("disruptor start success！");

        RingBuffer<DataEvent> ringBuffer = disruptor.getRingBuffer();
        DataProducer producer = new DataProducer(ringBuffer);
        //DataEventProducerWithTranslator translator = new DataEventProducerWithTranslator(ringBuffer);
        long start = System.currentTimeMillis();

        for (int l = 0; l < CompareTest.THREAD; l++) {
            new Thread(() -> {
                for (int m = 0; m < CompareTest.PER; m++) {
                    producer.onData(start);
                    // translator.onData(start);
                }
            }).start();
        }
        /**
         * 关闭 disruptor，方法会堵塞，直至所有的事件都得到处理；并不会自动关闭外部指定的executor,需要主动关闭
         */

        //disruptor.shutdown();
        //CompareTest.println("disruptor shutdown success！");
        //executor.shutdown();
    }
}


事件

/**
 * 创建时间：2021年5月19日 13:38:07
 * 创建作者：admin
 * 当前版本：v1.0
 * 基本功能：事件实例封装 业务数据传递对象
 */
public class DataEvent {
    private long startTime;

    public long getStartTime() {
        return startTime;
    }

    public void setStartTime(long startTime) {
        this.startTime = startTime;
    }

}

生产者

import com.lmax.disruptor.RingBuffer;
/**
 * 创建时间：2021年5月19日 13:38:07
 * 创建作者：admin
 * 当前版本：v1.0
 * 基本功能：当前还是生产线程
 *          onData用来发布事件，每调用一次就发布一次事件事件 它的参数会通过事件传递给消费者
 */
public class DataProducer {
    private final RingBuffer<DataEvent> ringBuffer;

    public DataProducer(RingBuffer<DataEvent> ringBuffer) {
        this.ringBuffer = ringBuffer;
    }
    public void onData(long data) {
		//获取下一个事件槽并发布事件要使用try/finally保证事件一定会被发布, 所以最好直接使用 ringBuffer.publishEvent方式将数据交由Translator来处理填充DataEvent，最后finally发布
        // 可以把ringBuffer看做一个事件队列，那么next就是得到下面一个事件槽, 若没有空闲的时间槽则阻塞
        long sequence = ringBuffer.next();
        // CompareTest.println("生产置入sequence:" + sequence);
        try {
            // 用上面的索引取出一个空的事件用于填充
            DataEvent event = ringBuffer.get(sequence);
            event.setStartTime(data);
        } finally {
            // 发布事件
            ringBuffer.publish(sequence);
        }
    }
}

import com.lmax.disruptor.EventTranslatorOneArg;
import com.lmax.disruptor.RingBuffer;

/**
 * 创建时间：2021年5月19日 13:38:07
 * 创建作者：admin
 * 当前版本：v1.0
 * 基本功能：获取下一个事件槽并发布事件（发布事件的时候要使用try/finally保证事件一定会被发布）。
 * 如果我们使用RingBuffer.next()获取一个事件槽，那么一定要发布对应的事件。
 * 如果不能发布事件，那么就会引起Disruptor状态的混乱。
 * 尤其是在多个事件生产者的情况下会导致事件消费者失速，从而不得不重启应用才能会恢复。
 */
public class DataEventProducerWithTranslator {
    private final RingBuffer<DataEvent> ringBuffer;

    /**
     * 一个translator可以看做一个事件初始化器，publicEvent方法会调用它
     * 填充Event
     */
    private static final EventTranslatorOneArg<DataEvent, Long> TRANSLATOR = new EventTranslatorOneArg<DataEvent, Long>() {
        public void translateTo(DataEvent event, long sequence, Long startTime) {
            event.setStartTime(startTime);
        }
    };

    public DataEventProducerWithTranslator(RingBuffer<DataEvent> ringBuffer) {
        this.ringBuffer = ringBuffer;
    }

    /*public void onData(Long bb) {
        ringBuffer.publishEvent(TRANSLATOR, bb);
        // 当前还是生产者线程
        // CompareTest.println(Thread.currentThread().getName() + " pulishEvent end!");

    }*/
}

消费者

import com.lmax.disruptor.EventHandler;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 创建时间：2021年5月19日 13:38:07
 * 创建作者：admin
 * 当前版本：v1.0
 * 基本功能：对指定事件的处理过程
 */
public class DataEventHandler implements EventHandler<DataEvent> {
    public AtomicLong count = new AtomicLong(0);

    /**
     * 消费者消费的入口 可以进行业务处理
     * @param event
     * @param sequence
     * @param endOfBatch
     * @throws Exception
     * @author admin
     * @date 2021年5月19日 13:38:07
     */
    @Override
    public void onEvent(DataEvent event, long sequence, boolean endOfBatch) throws Exception {
        /**
         * 消费者线程由初始化Disruptor时指定的threadFactory创建的
         */
        if (count.incrementAndGet() == CompareTest.TOTAL_COUNT) {
            CompareTest.println("处理的sequence：" + sequence + " count：" + count.get() + "  Disruptor 总耗时："
                    + (System.currentTimeMillis() - event.getStartTime()));
        }
    }

}



 

不知码农
关注
Disruptor(入门原理解析)
randomswap的博客
07-25 480
目录 简介 地址 特点 RingBuffer 开发步骤 小程序案例 生产者策略（ProducerType） 等待策略 消费者 简介 一般来说对于常用的中间队列外，除开kafka，rabbitmq，rocketmq，还有一个单机里比较有名的Disruptor。它是一个交易公司所开发的一个mq，最初是解决自己公司内部的一个消息处理。后被Oracle官方授予Duke大奖。因为它单机的效率的确是最高的。里面所有的优化都是做到了最好，优化到了cpu每次读取的缓存行都会特意的隔开。一个线程每秒可以
Disruptor系列2：Disruptor原理剖析
Coding Road
05-21 3811
都说Disruptor是高性能、低延迟的内存队列，每秒可以处理600W的订单，但是它为什么这么快呢？这就需要我们从他的底层设计原理开始剖析。我觉得，学习了他的实现原理，对自身了解Java并发内存结构是有很大的好处的，因为它把如何基于Java内存结构实现高性能的并发操作，解决锁的性能开销问题发挥到了极致。 无锁（Lock-Free） 要想提高内存队列的性能，首先需要解决的就是并发环境下锁的开销问...
Disruptor的使用以及原理
qq_39939541的博客
07-07 3667
Disruptor是一种高性能的并发框架，用于解决在高并发场景下的数据交换和协调问题。通过无锁的环形缓冲区和批量处理的方式，实现了更高的吞吐量和更低的延迟。它适用于需要处理大量并发事件的场景，如高频交易系统、消息队列等。
关于Disruptor监听策略
最新发布
IT界的奇葩
07-02 897
Disruptor框架提供了多种等待策略，每种策略都有其适用的场景和特点。
一种高效无锁内存队列的实现
foxox
02-05 672
Disruptor是LMAX公司开源的一个高效的内存无锁队列。这两天看了一下相关的设计文档和博客，下面尝试进行一下总结。 第一部分。引子 谈到并发程序设计，有几个概念是避免不了的。 1.锁：锁是用来做并发最简单的方式，当然其代价也是最高的。内核态的锁的时候需要操作系统进行一次上下文切换，等待锁的线程会被挂起直至锁释放。在上下文切换的时候，cpu之前缓存的指令和数据都将失效，对...
Disruptor原理探讨
dinglianluan8301的博客
09-21 277
之前谈到了在我的项目里用到了Disruptor，因为对它了解不足的原因，才会引发之前的问题，因此，今天特意来探讨其原理。 为什么采用Disruptor 先介绍一下我的这个服务。这个服务主要是作为游戏服务器的游戏逻辑部分，包括帧同步逻辑及其他在游戏过程中玩家产生的一些业务逻辑。 从用户量来说，现在最高峰大概有300人同时在线，游戏服务器设置1秒有30帧的数据量，因此，1秒内服务器接收到的...
Disruptor原理解析
hongtinghua的博客
05-30 1115
Disruptor 优点 没有用锁，使用了cpu的CAS，效率大大提高 没有使用队列来缓冲数据，而是使用了ringbuffer来避免竞争 每个访问者（包括生产者和消费者）都有自己的sequence来访问，减少竞争 使用cache line padding 来避免内存伪共享 RingBuffer 环形数组，随着你不停的往数组中填充数据，生产者的序号sequence会增长，绕过这个环 seque...
Disruptor原理
weixin_34121282的博客
05-08 304
基本知识 序列生产器Sequencer RingBuffer本质上是一个环状数组，数组大小固定。但是序列号会不断增加，然后取模得到数组下标，覆盖原有的数据。这样就可以无限增长。当生产者生产速度快于消费者时，要等待。。同理，消费者超前后，也要等待。。所有的消费和生产都依赖这个唯一的序列号。 序列生产器，分别有MultiProducerSequencer 和 SingleProducerSequen...
15、CPU缓存架构详解&高性能内存队列Disruptor实战
03-07
缓存的工作原理基于局部性原理，即程序倾向于在一段时间内连续访问相同或相邻的内存位置。通过将这些数据预先加载到缓存中，CPU可以更快地获取数据，从而提高执行速度。 CPU缓存的架构涉及到多个方面，如缓存行、...
Disruptor并发框架中文参考文档
11-17
### Disruptor并发框架知识点详解 #### 一、Disruptor简介及原理 **Disruptor** 是一款高性能、低延迟的并发框架，它通过无锁设计实现了高效的队列操作，从而大大提升了多线程环境下的性能表现。该框架于2011年...
DisruptorDemo.zip
06-09
《Disruptor技术详解——基于DisruptorDemo.zip实例解析》 Disruptor，由LMAX公司开发并开源，是一款高性能、低延迟的并发工具，主要用于优化多线程间的通信。它采用一种环形缓冲区（Ring Buffer）的设计，极大地...
disruptor技术培训
11-07
### Disruptor技术详解及其应用 #### 一、Disruptor框架概述 Disruptor是一个高性能的并发框架，主要用于解决高并发场景下的消息传递问题。它通过无锁设计实现了非常高的吞吐量和低延迟，这使得Disruptor在金融...
LMAX Disruptor 原理
weixin_34281477的博客
07-09 165
http://mechanitis.blogspot.com/search/label/disruptor http://ifeve.com/disruptor/, 并发框架Disruptor译文 http://blog.sina.com.cn/s/blog_68ffc7a4010150yl.html, 论文译文   LMAX需要搭建high performance的交易平台, 所以需要基...
Disruptor原理分析
zcswl7961的博客
09-11 4962
文章目录一 简介二 原理剖析三 代码 一 简介 Disruptor是一个性能极强的异步消息处理框架，可以认为它是线程间通信高效低延时的内存消息组件，它最大的特点是高性能，其LMAX架构可以获得每秒6百万订单，用1微秒的延迟获得吞吐量为100K+。实际上它是拿内存换取处理高性能的低延迟的处理熟速度， （实际上这个框架在log4j，以及activeMQ源码扩展中有使用） 二 原理剖析 并发编程网上有...
Disruptor机制原理
paul_wei2008的专栏
05-09 941
ProducerBarriers Disruptor 代码​ 给 消费者 提供了一些接口和辅助类，但是没有给写入 Ring Buffer 的 生产者 提供接口。这是因为除了你需要知道生产者之外，没有别人需要访问它。尽管如此，Ring Buffer 还是与消费端一样提供了一个 ProducerBarrier 对象，让生产者通过它来写入 Ring Buffer。 写入 Ring Buffer
无锁并发框架-Disruptor的原理（一）
zhouhengzhe的博客
12-30 1993
这里写自定义目录标题一、Disruptor是什么1、定义2、应用场景3、类似4、核心设计原理5、数据结构5.1、Sequence是什么5.2、数组+序列号设计的优势6、核心组件与作用7、写数据8、使用 一、Disruptor是什么 1、定义 Disruptor是一个开源框架，研发的初衷是为了解决高并发下列队锁的问题，最早由LMAX（一种新型零售金融交易平台）提出并使用，能够在无锁的情况下实现队列的并发操作，并号称能够在一个线程里每秒处理6百万笔订单。 2、应用场景 生产消费者模型 3、类似 条件阻塞
disruptor原理分析
休息的风的专栏
03-10 814
简介 理解Disruptor是什么的最好方法是将它与目前很好理解和非常相似的东西进行比较。与Java的 BlockingQueue队列一样，Disruptor的目的是在同一进程内的线程之间移动数据（例如消息或事件）。但是，Disruptor提供了一些将其与队列区分开来的关键功能。他们是： 具有消费者依赖关系图的消费者多播事件。 为事件预先分配内存。 可选择无锁。 使用场景 Disruptor的...
Disruptor关系组装：高性能并发框架的菱形结构详解
本文主要探讨了Disruptor，一个高性能、低延迟的无锁并发框架，由LMAX公司开发，用于实现高效的事件驱动处理。Disruptor的设计理念在于解决并发编程中的锁问题，提高性能和减少竞争。文章首先介绍了Disruptor的基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值