高性能并发框架Disruptor

最新推荐文章于 2020-12-09 10:52:00 发布

chengbinbbs

最新推荐文章于 2020-12-09 10:52:00 发布

阅读量521

点赞数

分类专栏：并发文章标签： disruptor 队列并发高性能 RingBuffer

本文链接：https://blog.csdn.net/chengbinbbs/article/details/102461915

版权

并发专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、Disruptor是什么

Disruptor是一个开源的并发框架，能够在无锁的情况下实现网络的Queue并发操作。
Disruptor是一个高性能的异步处理框架，或者可以认为是最快的消息框架（轻量级JMS），也可以认为是一个观察者模式的实现，或者事件监听模式的实现。

二、Disruptor核心概念

RingBuffer：
被看做Disruptor最主要组件，然而从3.0开始RingBuffer仅仅负责存储和更新在Disruptor中流通的数据。对一些特殊的使用场景能够被用户（其他数据结构）完全替代。
Sequence：
Disruptor使用Sequence来表示一个特殊组件处理的序号。和Disruptor一样，每个消费者（EventProcessor）都维持着一个Sequence。大部分的并发代码依赖这些Sequence值得运转，因此Sequence支持多种当前为AtomicLong类的特性。
Sequencer：
这是Disruptor真正的核心。实现了这个接口的两种生产者（单生产者和多生产者）均实现了所有的并发算法，为了在生产者和消费者之间进行准确快速的数据传递。
SequenceBarrier：
有Sequence生成，并且包含了已经发布的Sequence的引用，这些Sequence源于Sequenceer和一些独立的消费者的Sequence。它包含了决定是否有供消费者来消费者的Event的逻辑。
WaitStrategy：
决定了一个消费者将如何等待生产者将Event置于Disruptor。
Event：
从生产者到消费者过程中所处理的数据单元。Disruptor中没有代码表示Event，因此它完全是由用户定义。
EventProcessor：
主要时间循环，处理Disruptor中的Event，并且拥有消费者的Sequence。他有一个实现类是BatchEventProcessor，包含了event loop有效的实现，并且将回调到一个EventHandler接口的实现对象。
EventHandler：
由用户实现并且代表了Disruptor中的一个消费者的接口。
Producer：
由用户实现，它调用RingBuffer来插入事件（Event），在Disruptor中没有相应的实现代码，由用户实现。
WorkProcessor：
确保每个sequence只被一个processor消费，在同一个WorkPool中的处理多个WorkProcessor不会消费同样的sequence。
WorkerPool：
一个WorkProcessor池，其中WorkProcessor将消费Sequence，所以任务可以在实现WorkHandler接口的worker之间移交。
LifecycleAware：
当BatchEventProcessor启动和停止时，实现这个接口用于接收通知。

三、Disruptor工作原理

Disruptor的核心是RingBuffer，主要用来存储和更新数据，生产者负责往RingBuffer中写数据，消费者从RingBuffer中消费数据。
在这里插入图片描述
RingBuffer其实就是一个环，首尾连接的一个环，只维护一个next()指向的下一个元素，当数据超过最大的限制的时候，其实就是一个覆盖操作，打个比方现在RingBuffer的长度为2^3=8，将下标从0到7的索引填满之后，下一个索引应该是8，这个时候其实只需要进行简单的取模操作即可，8%8就是覆盖第0个元素对象的数据，12的话就是12%8=4，就覆写索引下标为4的位置。
之前有说RingBuffer中槽的大小需要是2^n，这样是因为假如是2的n次方的话，进行操作完全可以用位运算，这是速度非常快的，比如: 8 >> 1 = 4 8 << 1 = 16

四、Disruptor使用

在Disruptor开发过程中，主要需要实现如下几个步骤：

1.定义事件

事件(Event)就是通过 Disruptor 进行交换的数据类型

public class LongEvent {

	private long value;

	public long getValue() {
		return value;
	}

	public void setValue(long value) {
		this.value = value;
	}
}

2.定义事件工厂

事件工厂(Event Factory)定义了如何实例化前面第1步中定义的事件(Event)，需要实现接口 com.lmax.disruptor.EventFactory。
Disruptor 通过 EventFactory 在 RingBuffer 中预创建 Event 的实例。

一个 Event 实例实际上被用作一个“数据槽”，发布者发布前，先从 RingBuffer 获得一个 Event 的实例，然后往 Event 实例中填充数据，之后再发布到 RingBuffer 中，之后由 Consumer 获得该 Event 实例并从中读取数据。

/**
 * 需要让disruptor为我们创建事件，我们同时还声明一个EventFactory来实例化Event对象
 * */
public class LongEventFactory implements EventFactory<LongEvent>{

	@Override
	public Object newInstance() {
		return new LongEvent();
	}

}

3.定义事件监听器类

通过实现接口 com.lmax.disruptor.EventHandler 定义事件处理的具体实现。

/**
 * 事件消费者：
 * 也就是一个事件处理器，这个事件处理器简单地把事件中存储的数据打印到终端
 * */
public class LongEventHandler implements EventHandler<LongEvent> {

	@Override
	public void onEvent(LongEvent arg0, long arg1, boolean arg2) throws Exception {
		System.out.println(arg0.getValue());
	}

}

4.定义用于事件处理的线程池

Disruptor 通过 java.util.concurrent.ExecutorService 提供的线程来触发 Consumer 的事件处理。例如：

ExecutorService executor = Executors.newCachedThreadPool();

5.指定等待策略

Disruptor 定义了 com.lmax.disruptor.WaitStrategy 接口用于抽象 Consumer 如何等待新事件，这是策略模式的应用。

Disruptor 提供了多个 WaitStrategy 的实现，每种策略都具有不同性能和优缺点，根据实际运行环境的 CPU 的硬件特点选择恰当的策略，并配合特定的 JVM 的配置参数，能够实现不同的性能提升。

例如，BlockingWaitStrategy、SleepingWaitStrategy、YieldingWaitStrategy 等，其中，

BlockingWaitStrategy 是最低效的策略，但其对CPU的消耗最小并且在各种不同部署环境中能提供更加一致的性能表现；
SleepingWaitStrategy 的性能表现跟 BlockingWaitStrategy 差不多，对 CPU 的消耗也类似，但其对生产者线程的影响最小，适合用于异步日志类似的场景；
YieldingWaitStrategy 的性能是最好的，适合用于低延迟的系统。在要求极高性能且事件处理线数小于 CPU 逻辑核心数的场景中，推荐使用此策略；例如，CPU开启超线程的特性。

WaitStrategy BLOCKING_WAIT = new BlockingWaitStrategy();
WaitStrategy SLEEPING_WAIT = new SleepingWaitStrategy();
WaitStrategy YIELDING_WAIT = new YieldingWaitStrategy();

6.启动 Disruptor

EventFactory<LongEvent> eventFactory = new LongEventFactory();
ExecutorService executor = Executors.newSingleThreadExecutor();
int ringBufferSize = 1024 * 1024; // RingBuffer 大小，必须是 2 的 N 次方；
 
Disruptor<LongEvent> disruptor = new Disruptor<LongEvent>(eventFactory,
                ringBufferSize, executor, ProducerType.SINGLE,
                new YieldingWaitStrategy());
 
EventHandler<LongEvent> eventHandler = new LongEventHandler();
disruptor.handleEventsWith(eventHandler);
 
disruptor.start();

7.发布事件

Disruptor 的事件发布过程是一个两阶段提交的过程：

第一步：先从 RingBuffer 获取下一个可以写入的事件的序号；
第二步：获取对应的事件对象，将数据写入事件对象；
第三步：将事件提交到 RingBuffer;

事件只有在提交之后才会通知 EventProcessor 进行处理；

// 发布事件；
RingBuffer<LongEvent> ringBuffer = disruptor.getRingBuffer();
long sequence = ringBuffer.next();//请求下一个事件序号；
 
try {
    LongEvent event = ringBuffer.get(sequence);//获取该序号对应的事件对象；
    long data = getEventData();//获取要通过事件传递的业务数据；
    event.set(data);
} finally{
    ringBuffer.publish(sequence);//发布事件；
}

注意，最后的 ringBuffer.publish 方法必须包含在 finally 中以确保必须得到调用；如果某个请求的 sequence 未被提交，将会堵塞后续的发布操作或者其它的 producer。

8.关闭 Disruptor

disruptor.shutdown();//关闭 disruptor，方法会堵塞，直至所有的事件都得到处理；
executor.shutdown();//关闭 disruptor 使用的线程池；如果需要的话，必须手动关闭， disruptor 在 shutdown 时不会自动关闭；

4~8步主要是实例化Disruptor实例，定义用于事件处理的线程池，指定等待策略，配置一系列参数。然后我们对Disruptor实例绑定监听事件类，接收并处理数据。

public class LongEventMain {

	public static void main(String[] args) {
		//创建线程池
		ExecutorService executor = Executors.newCachedThreadPool();
		//创建工程
		LongEventFactory factory = new LongEventFactory();
		//创建bufferSize，也就是RingBuffer大小，必须是2的N次方
		int ringBufferSize = 1024 * 1024;
		/**
        BlockingWaitStrategy 是最低效的策略，但其对CPU的消耗最小并且在各种不同部署环境中能提供更加一致的性能表现
        WaitStrategy BLOCKING_WAIT = new BlockingWaitStrategy();
        SleepingWaitStrategy 的性能表现跟BlockingWaitStrategy差不多，对CPU的消耗也类似，但其对生产者线程的影响最小，适合用于异步日志类似的场景
        WaitStrategy SLEEPING_WAIT = new SleepingWaitStrategy();
        YieldingWaitStrategy 的性能是最好的，适合用于低延迟的系统。在要求极高性能且事件处理线数小于CPU逻辑核心数的场景中，推荐使用此策略；例如，CPU开启超线程的特性
        WaitStrategy YIELDING_WAIT = new YieldingWaitStrategy();
        */
		/* 创建disruptor
		 * 1.第一个参数为工厂类对象，用于创建一个个的LongEvent，LongEvent是实际的消费数据。
		 * 2.第二个参数为缓存区大小
		 * 3.第三个参数为线程池，进行Disruptor内部的数据接收处理调度
		 * 4.第四个参数ProducerType.SINGLE(表示一个生产者) 和 ProducerType.MULTI(多个生产者)
		 * 5.第五个参数是一种策略，就是生产和消费的策略
		 * */
		Disruptor<LongEvent> disruptor = new Disruptor<>(factory, ringBufferSize, executor, ProducerType.SINGLE, new YieldingWaitStrategy());
		
		//连接消费事件方法
		disruptor.handleEventsWith(new LongEventHandler());
		
		//启动
		disruptor.start();
		
		//Disruptor的事件发布过程是一个两阶段提交过程
		//使用该方法获得具体存放数据的容器RingBuffer（环形结构）
		RingBuffer<LongEvent> ringBuffer = disruptor.getRingBuffer();
		
		LongEventProducer producer = new LongEventProducer(ringBuffer);
		
		ByteBuffer byteBuffer = ByteBuffer.allocate(8);
		for(long input = 0; input < 100; input++){
			byteBuffer.putLong(0,input);
			producer.onData(byteBuffer);
		}
		
		disruptor.shutdown(); //关闭disruptor，方法会阻塞，直到所有的时间得到处理
		executor.shutdown(); //关闭executor，disruptor不会自动关闭executor
		
	}

}

public class LongEventProducer {

	private final RingBuffer<LongEvent> ringBuffer;
	
	public LongEventProducer(RingBuffer<LongEvent> ringBuffer){
		this.ringBuffer = ringBuffer;
	}
	
	/**
	 * onData用来发布事件，每调用一次就发布一次事件
	 * 他的参数会用该事件传递给消费者
	 * */
	public void onData(ByteBuffer input){
		//1.把ringBuffer看做一个事件队列，那么next就是得到下一个事件槽
		long sequence = ringBuffer.next();
		try{
			//2.用上面的索引取出一个空的事件用于填充（获取该序号对应的事件对象）
			LongEvent event = ringBuffer.get(sequence);
			//3.获取要通过事件传递的业务数据
			event.setValue(input.getLong(0));
		} finally {
			//4.发布事件
			//注意，最后的ringBuffer.publish 方法必须包含在finally中以确保必须得到调用
			//如果某个请求的sequence未被提交，则对应的消费者获取不了数据
			ringBuffer.publish(sequence);
		}
	}
}

注意：对Disruptor实例绑定监听事件类有两种方式，使用handleEventsWithWorkerPool可以完成不重复消费，使用handleEventsWith就是重复消费。

handleEventsWith

//连接消费事件方法
disruptor.handleEventsWith(new LongEventHandler());

handleEventsWithWorkerPool

这次的消费者需要实现不同的接口，实现的是WorkHandler接口

import com.lmax.disruptor.WorkHandler;
 
public class Consumer implements WorkHandler<LongEvent> {
    @Override
    public void onEvent(LongEvent longEvent) throws Exception {
        System.out.println(Thread.currentThread().getName() + "消费者消费了消息：" + longEvent.toString());
    }
}

public class Test {
    public static void main(String[] args) {
        ThreadFactory producerFactory = Executors.defaultThreadFactory();
        // 创建缓冲池
        LongEventFactory eventFactory = new LongEventFactory();
 
        // 创建bufferSize ,也就是RingBuffer大小，必须是2的N次方
        int ringBufferSize = 1024 * 1024;
        Disruptor<LongEvent> disruptor = new Disruptor<>(eventFactory, ringBufferSize, producerFactory,
                ProducerType.SINGLE, new BlockingWaitStrategy());
        RingBuffer<LongEvent> ringBuffer = disruptor.getRingBuffer();
 
        // 创建10个消费者来处理同一个生产者发的消息(这10个消费者不重复消费消息)
        Consumer[] consumers = new Consumer[10];
        for (int i = 0; i < consumers.length; i++) {
            consumers[i] = new Consumer();
        }
        disruptor.handleEventsWithWorkerPool(consumers);
 
        disruptor.start();
 
        LongEventProducer longEventProducer = new LongEventProducer(ringBuffer);
        ByteBuffer bb = ByteBuffer.allocate(8);
        for (long i = 0; i < 100L; i++) {
            bb.putLong(0, i);
            longEventProducer.onData(bb);
        }
 
        disruptor.shutdown();
    }
}