简单使用Disruptor

最新推荐文章于 2023-10-05 18:08:54 发布
最新推荐文章于 2023-10-05 18:08:54 发布
阅读量3k 收藏 3
点赞数
分类专栏： # 【Disruptor】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zero__007/article/details/49684363
版权
1.定义事件与事件工厂
       事件(Event)就是通过 Disruptor 进行交换的数据类型。
       事件工厂(Event Factory)定义了如何实例化事件(Event)，需要实现接口 com.lmax.disruptor.EventFactory<T>。Disruptor 通过EventFactory在 RingBuffer 中预创建 Event 的实例。一个 Event 实例实际上被用作一个“数据槽”，发布者发布前，先从RingBuffer 获得一个Event的实例，然后往Event 实例中填充数据，之后再发布到 RingBuffer 中，之后由Consumer 获得该 Event 实例并从中读取数据。
 
package com.zero.disruptor;

import com.lmax.disruptor.EventFactory;

public class SimpleEvent {
	private String value;

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

	public String getValue() {
		return value;
	}

	public static final EventFactory<SimpleEvent> FACTORY = new EventFactory<SimpleEvent>() {
		@Override
		public SimpleEvent newInstance() {
			return new SimpleEvent();
		}
	};
}
2. 定义事件处理的具体实现
       通过实现接口 com.lmax.disruptor.EventHandler<T> 定义事件处理的具体实现，实际上就是消费者。 
package com.zero.disruptor;

import java.util.concurrent.TimeUnit;

import com.lmax.disruptor.EventHandler;
import com.lmax.disruptor.WorkHandler;

/**
 * EventHandlers是BatchEventProcessor要用到的， WorkHandler是WorkerPool要用到的。为简便放在了一起
 */
public class SimpleHandler implements EventHandler<SimpleEvent>,
		WorkHandler<SimpleEvent> {
	private String handlerName;

	public SimpleHandler(String handlerName) {
		this.handlerName = handlerName;
	}

	@Override
	// Override---EventHandler
	public void onEvent(SimpleEvent event, long sequence, boolean endOfBatch)
			throws Exception {
		TimeUnit.MILLISECONDS.sleep(100);
		System.out.println(handlerName + " before deal : sequence = "
				+ sequence + ", Event: " + event.getValue());
		event.setValue(event.getValue() + "--" + handlerName);
		System.out.println(handlerName + " after  deal : "
				+ "Event: " + event.getValue());
	}

	@Override
	// Override---WorkHandler
	public void onEvent(SimpleEvent event) throws Exception {
		// TODO Auto-generated method stub
		TimeUnit.MILLISECONDS.sleep(100);
		System.out.println(handlerName + " before deal :  Event: "
				+ event.getValue());
		event.setValue(event.getValue() + "--" + handlerName);
		System.out.println(handlerName + " after  deal : "
				+ " Event: " + event.getValue());
	}

}
3. 等待策略
       Disruptor 定义了 com.lmax.disruptor.WaitStrategy 接口用于抽象Consumer如何等待新事件，这是策略模式的应用。
       Disruptor 提供了多个WaitStrategy 的实现，每种策略都具有不同性能和优缺点，根据实际运行环境的 CPU 的硬件特点选择恰当的策略，并配合特定的 JVM 的配置参数，能够实现不同的性能提升。
       例如，BlockingWaitStrategy、SleepingWaitStrategy、YieldingWaitStrategy 等，其中，BlockingWaitStrategy 是最低效的策略，但其对CPU的消耗最小并且在各种不同部署环境中能提供更加一致的性能表现；SleepingWaitStrategy的性能表现跟BlockingWaitStrategy差不多，对CPU的消耗也类似，但其对生产者线程的影响最小，适合用于异步日志类似的场景；YieldingWaitStrategy 的性能是最好的，适合用于低延迟的系统。在要求极高性能且事件处理线数小于CPU逻辑核心数的场景中。
       • BlockingWaitStrategy: 对低延迟和吞吐率不像CPU占用那么重要
       • BusySpinWaitStrategy： CPU使用率高，低延迟
       • LiteBlockingWaitStrategy: BlockingWaitStrategy变种，实验性的
       • PhasedBackoffWaitStrategy： Spins, then yields, then waits，不过还是适合对低延迟和吞吐率不像CPU占用那么重要的情况
       • SleepingWaitStrategy: spin， then yield，然后sleep(LockSupport.parkNanos(1L))在性能和CPU占用率之间做了平衡。
       • TimeoutBlockingWaitStrategy： sleep一段时间。 低延迟。
       • YieldingWaitStrategy： 使用spin, Thread.yield()方式

4.发布事件
       Disruptor 的事件发布过程是一个两阶段提交的过程：
       第一步：先从 RingBuffer 获取下一个可以写入的事件的序号；
       第二步：获取对应的事件对象，将数据写入事件对象；
       第三部：将事件提交到 RingBuffer;
       事件只有在提交之后才会通知 EventProcessor 进行处理；ringBuffer.publish 方法最好包含在 finally中以确保必须得到调用；因为如果某个请求的sequence未被提交，将会堵塞后续的发布操作或者其它的producer。 
long seq = 0;
for (int i = 0; i < 20; i++) {
	try {
		seq = ringBuffer.next();// 占个坑 ,ringBuffer一个可用区块
		ringBuffer.get(seq).setValue((long) (Math.random() * 9999));// 给这个区块放入数据
	} finally {
		ringBuffer.publish(seq);// 发布这个区块的数据使handler(consumer)可见
		System.out.println("Producer " + seq);
	}
}
Disruptor 还提供另外一种形式的调用来简化以上操作，并确保 publish 总是得到调用。 
package com.zero.disruptor;

import java.nio.ByteBuffer;

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

public class SimpleEventProducer {
	private final RingBuffer<SimpleEvent> ringBuffer;

	public SimpleEventProducer(RingBuffer<SimpleEvent> ringBuffer) {
		this.ringBuffer = ringBuffer;
	}

	private static final EventTranslatorOneArg TRANSLATOR = new EventTranslatorOneArg<SimpleEvent, String>() {
		@Override
		public void translateTo(SimpleEvent event, long sequence, String value) {
			System.out.println("Producer --- " + sequence + ", event = "
					+ value);
			event.setValue(value);
		}
	};

	/**
	 * onData用来发布事件
	 * 
	 * @param value
	 */
	public void onData(final String value) {
		ringBuffer.publishEvent(TRANSLATOR, value);
	}

}
5. 关闭 Disruptor 
disruptor.shutdown();//关闭 disruptor，方法会堵塞，直至所有的事件都得到处理；
executor.shutdown();//关闭 disruptor 使用的线程池；如果需要的话，必须手动关闭， disruptor 在 shutdown 时不会自动关闭；
6.示例1： 
	public static void demo0() throws Exception {
		/*
		 * createSingleProducer创建一个单生产者的RingBuffer，
		 * 第一个参数叫EventFactory，从名字上理解就是“事件工厂”，其实它的职责就是产生数据填充RingBuffer的区块。
		 * 第二个参数是RingBuffer的大小，它必须是2的指数倍 目的是为了将求模运算转为&运算提高效率
		 * 第三个参数是RingBuffer的生产都在没有可用区块的时候(可能是消费者（或者说是事件处理器） 太慢了)的等待策略
		 */
		final RingBuffer<SimpleEvent> ringBuffer = RingBuffer
				.createSingleProducer(SimpleEvent.FACTORY, 2,
						new SleepingWaitStrategy());
		// 创建线程池
		ExecutorService executors = Executors.newCachedThreadPool();

		// 创建SequenceBarrier
		SequenceBarrier sequenceBarrier = ringBuffer.newBarrier();

		// 创建消息处理器 ,消费者
		BatchEventProcessor<SimpleEvent> processor1 = new BatchEventProcessor<SimpleEvent>(
				ringBuffer, sequenceBarrier, new SimpleHandler(
						"EventHandler_01"));
		// 传入所有消费者线程的序号,如果只有一个消费者的情况可以省略
		ringBuffer.addGatingSequences(processor1.getSequence());
		// 把消息处理器提交到线程池
		executors.submit(processor1);
		// 如果存在多个消费者 那重复执行上面3行代码 把SimpleHandler换成其它消费者类

		BatchEventProcessor<SimpleEvent> processor2 = new BatchEventProcessor<SimpleEvent>(
				ringBuffer, sequenceBarrier, new SimpleHandler(
						"EventHandler_02"));
		ringBuffer.addGatingSequences(processor2.getSequence());
		executors.submit(processor2);
		// 两个消费者会消费一样的事件

		// 生产者
		SimpleEventProducer producer = new SimpleEventProducer(ringBuffer);
		for (int i = 0; i < 4; i++) {
			producer.onData(String.valueOf(i));
		}
		processor1.halt();// 通知事件(或者说消息)处理器可以结束了（并不是马上结束!!!）
		processor2.halt();
		executors.shutdown();// 终止线程
	}
运行结果： 
Producer --- 0, event = 0
Producer --- 1, event = 1
EventHandler_02 before deal : sequence = 0, Event: 0
EventHandler_02 after  deal : Event: 0--EventHandler_02
EventHandler_01 before deal : sequence = 0, Event: 0--EventHandler_02
EventHandler_01 after  deal : Event: 0--EventHandler_02--EventHandler_01
EventHandler_02 before deal : sequence = 1, Event: 1
EventHandler_02 after  deal : Event: 1--EventHandler_02
EventHandler_01 before deal : sequence = 1, Event: 1--EventHandler_02
EventHandler_01 after  deal : Event: 1--EventHandler_02--EventHandler_01
Producer --- 2, event = 2
Producer --- 3, event = 3
EventHandler_01 before deal : sequence = 2, Event: 2
EventHandler_01 after  deal : Event: 2--EventHandler_01
EventHandler_02 before deal : sequence = 2, Event: 2--EventHandler_01
EventHandler_02 after  deal : Event: 2--EventHandler_01--EventHandler_02
EventHandler_01 before deal : sequence = 3, Event: 3
EventHandler_01 after  deal : Event: 3--EventHandler_01
EventHandler_02 before deal : sequence = 3, Event: 3--EventHandler_01
EventHandler_02 after  deal : Event: 3--EventHandler_01--EventHandler_02

可以看出，每个event都被处理了，但是先后顺序不同，如果需要有先后顺序，可以采用一下方式：

	public static void demo1() throws Exception {
		final RingBuffer<SimpleEvent> ringBuffer = RingBuffer
				.createSingleProducer(SimpleEvent.FACTORY, 2,
						new SleepingWaitStrategy());
		ExecutorService executors = Executors.newCachedThreadPool();

		SequenceBarrier stepOneSequenceBarrier = ringBuffer.newBarrier();
		BatchEventProcessor<SimpleEvent> processor1 = new BatchEventProcessor<SimpleEvent>(
				ringBuffer, stepOneSequenceBarrier, new SimpleHandler(
						"EventHandler_01"));
		executors.submit(processor1);

		SequenceBarrier stepTwoSequenceBarrier = ringBuffer
				.newBarrier(processor1.getSequence());
		BatchEventProcessor<SimpleEvent> processor2 = new BatchEventProcessor<SimpleEvent>(
				ringBuffer, stepTwoSequenceBarrier, new SimpleHandler(
						"EventHandler_02"));
		
		//processor2消费最慢，所以以processor2的Sequence为阈值
		ringBuffer.addGatingSequences(processor2.getSequence());
		
		executors.submit(processor2);

		// 生产者
		SimpleEventProducer producer = new SimpleEventProducer(ringBuffer);
		for (int i = 0; i < 4; i++) {
			producer.onData(String.valueOf(i));
		}
		
		executors.shutdown();// 终止线程
	}
运行结果： 

Producer --- 0, event = 0
Producer --- 1, event = 1
EventHandler_01 before deal : sequence = 0, Event: 0
EventHandler_01 after  deal : Event: 0--EventHandler_01
EventHandler_01 before deal : sequence = 1, Event: 1
EventHandler_01 after  deal : Event: 1--EventHandler_01
EventHandler_02 before deal : sequence = 0, Event: 0--EventHandler_01
EventHandler_02 after  deal : Event: 0--EventHandler_01--EventHandler_02
EventHandler_02 before deal : sequence = 1, Event: 1--EventHandler_01
EventHandler_02 after  deal : Event: 1--EventHandler_01--EventHandler_02
Producer --- 2, event = 2
Producer --- 3, event = 3
EventHandler_01 before deal : sequence = 2, Event: 2
EventHandler_01 after  deal : Event: 2--EventHandler_01
EventHandler_01 before deal : sequence = 3, Event: 3
EventHandler_01 after  deal : Event: 3--EventHandler_01
EventHandler_02 before deal : sequence = 2, Event: 2--EventHandler_01
EventHandler_02 after  deal : Event: 2--EventHandler_01--EventHandler_02
EventHandler_02 before deal : sequence = 3, Event: 3--EventHandler_01
EventHandler_02 after  deal : Event: 3--EventHandler_01--EventHandler_02
如果想一个消息只被一个消费者消费呢？ 
	public static void demo2() throws Exception {
		final RingBuffer<SimpleEvent> ringBuffer = RingBuffer
				.createSingleProducer(SimpleEvent.FACTORY, 4,
						new SleepingWaitStrategy());
		ExecutorService executors = Executors.newCachedThreadPool();

		SequenceBarrier sequenceBarrier = ringBuffer.newBarrier();

		// 创建消息处理器 ,消费者
		WorkHandler<SimpleEvent> processor1 = new SimpleHandler("WorkHandler_1");
		WorkHandler<SimpleEvent> processor2 = new SimpleHandler("WorkHandler_2");
		WorkerPool<SimpleEvent> workerPool = new WorkerPool<SimpleEvent>(
				ringBuffer, sequenceBarrier, new IgnoreExceptionHandler(),
				processor1, processor2);
		ringBuffer.addGatingSequences(workerPool.getWorkerSequences());// 要在workerPool.start(executors);之前
		workerPool.start(executors);

		// 生产者
		SimpleEventProducer producer = new SimpleEventProducer(ringBuffer);
		for (int i = 0; i < 4; i++) {
			producer.onData(String.valueOf(i));
		}
		workerPool.halt();
		executors.shutdown();// 终止线程
	}
运行结果： 
Producer --- 0, event = 0
Producer --- 1, event = 1
Producer --- 2, event = 2
Producer --- 3, event = 3
WorkHandler_2 before deal :  Event: 1
WorkHandler_1 before deal :  Event: 0
WorkHandler_1 after  deal :  Event: 0--WorkHandler_1
WorkHandler_2 after  deal :  Event: 1--WorkHandler_2
WorkHandler_1 before deal :  Event: 2
WorkHandler_2 before deal :  Event: 3
WorkHandler_2 after  deal :  Event: 3--WorkHandler_2
WorkHandler_1 after  deal :  Event: 2--WorkHandler_1
如果想一个消息被两组消费者消费，但是每组只能有一个消费？ 
	public static void demo3() throws Exception {
		final RingBuffer<SimpleEvent> ringBuffer = RingBuffer
				.createSingleProducer(SimpleEvent.FACTORY, 4,
						new SleepingWaitStrategy());
		ExecutorService executors = Executors.newCachedThreadPool();

		SequenceBarrier sequenceBarrier = ringBuffer.newBarrier();

		// 创建消息处理器 ,消费者
		WorkHandler<SimpleEvent> processor1 = new SimpleHandler("WorkHandler_1");
		WorkHandler<SimpleEvent> processor2 = new SimpleHandler("WorkHandler_2");
		WorkerPool<SimpleEvent> workerPool = new WorkerPool<SimpleEvent>(
				ringBuffer, sequenceBarrier, new IgnoreExceptionHandler(),
				processor1, processor2);
		ringBuffer.addGatingSequences(workerPool.getWorkerSequences());// 要在workerPool.start(executors);之前
		workerPool.start(executors);

		
		// 创建消息处理器 ,消费者
		WorkerPool<SimpleEvent> workerPool2 = new WorkerPool<SimpleEvent>(
				ringBuffer, sequenceBarrier, new IgnoreExceptionHandler(),
				new SimpleHandler("WorkHandler_3"));
		ringBuffer.addGatingSequences(workerPool2.getWorkerSequences());// 要在workerPool.start(executors);之前
		workerPool2.start(executors);
		
		// 生产者
		SimpleEventProducer producer = new SimpleEventProducer(ringBuffer);
		for (int i = 0; i < 4; i++) {
			producer.onData(String.valueOf(i));
		}
		workerPool.halt();
		executors.shutdown();// 终止线程
	}
运行结果： 
Producer --- 0, event = 0
Producer --- 1, event = 1
Producer --- 2, event = 2
Producer --- 3, event = 3
WorkHandler_2 before deal :  Event: 1
WorkHandler_3 before deal :  Event: 0
WorkHandler_3 after  deal :  Event: 0--WorkHandler_3
WorkHandler_1 before deal :  Event: 0
WorkHandler_1 after  deal :  Event: 0--WorkHandler_3--WorkHandler_1
WorkHandler_2 after  deal :  Event: 1--WorkHandler_2
WorkHandler_2 before deal :  Event: 3
WorkHandler_1 before deal :  Event: 2
WorkHandler_1 after  deal :  Event: 2--WorkHandler_1
WorkHandler_2 after  deal :  Event: 3--WorkHandler_2
WorkHandler_3 before deal :  Event: 1--WorkHandler_2
WorkHandler_3 after  deal :  Event: 1--WorkHandler_2--WorkHandler_3
WorkHandler_3 before deal :  Event: 2--WorkHandler_1
WorkHandler_3 after  deal :  Event: 2--WorkHandler_1--WorkHandler_3
WorkHandler_3 before deal :  Event: 3--WorkHandler_2
WorkHandler_3 after  deal :  Event: 3--WorkHandler_2--WorkHandler_3

7.示例2： 
	public static void work1() {
		ExecutorService executor = Executors.newFixedThreadPool(2);
		int ringBufferSize = 2; // RingBuffer 大小，必须是 2 的 N 次方；
		// 构造Disruptor
		Disruptor<SimpleEvent> disruptor = new Disruptor<SimpleEvent>(
				SimpleEvent.FACTORY, ringBufferSize, executor,
				ProducerType.SINGLE, new BlockingWaitStrategy());

		disruptor.handleEventsWith(new SimpleHandler("BatchEventHandler_01"),
				new SimpleHandler("BatchEventHandler_02"));
		// 每个EventHandler占用一个线程，如果Executors.newFixedThreadPool(1);会导致阻塞

		RingBuffer<SimpleEvent> ringBuffer = disruptor.start();

		// 生产者
		SimpleEventProducer producer = new SimpleEventProducer(ringBuffer);
		for (long i = 10; i < 15; i++) {
			producer.onData(String.valueOf(i));
		}
		
		// 关闭 Disruptor
		disruptor.shutdown();// 关闭 disruptor，方法会堵塞，直至所有的事件都得到处理；
		executor.shutdown();// 关闭 disruptor 使用的线程池；如果需要的话，必须手动关闭，
							// disruptor在shutdown 时不会自动关闭；
	}
以上示例，效果等同于demo0。运行结果; 
Producer --- 0, event = 10
Producer --- 1, event = 11
BatchEventHandler_02 before deal : sequence = 0, Event: 10
BatchEventHandler_02 after  deal : Event: 10--BatchEventHandler_02
BatchEventHandler_01 before deal : sequence = 0, Event: 10
BatchEventHandler_01 after  deal : Event: 10--BatchEventHandler_02--BatchEventHandler_01
BatchEventHandler_01 before deal : sequence = 1, Event: 11
BatchEventHandler_01 after  deal : Event: 11--BatchEventHandler_01
BatchEventHandler_02 before deal : sequence = 1, Event: 11--BatchEventHandler_01
BatchEventHandler_02 after  deal : Event: 11--BatchEventHandler_01--BatchEventHandler_02
Producer --- 2, event = 12
Producer --- 3, event = 13
BatchEventHandler_01 before deal : sequence = 2, Event: 12
BatchEventHandler_02 before deal : sequence = 2, Event: 12
BatchEventHandler_02 after  deal : Event: 12--BatchEventHandler_02
BatchEventHandler_01 after  deal : Event: 12--BatchEventHandler_02--BatchEventHandler_01
BatchEventHandler_02 before deal : sequence = 3, Event: 13
BatchEventHandler_02 after  deal : Event: 13--BatchEventHandler_02
BatchEventHandler_01 before deal : sequence = 3, Event: 13--BatchEventHandler_02
BatchEventHandler_01 after  deal : Event: 13--BatchEventHandler_02--BatchEventHandler_01
Producer --- 4, event = 14
BatchEventHandler_02 before deal : sequence = 4, Event: 14
BatchEventHandler_02 after  deal : Event: 14--BatchEventHandler_02
BatchEventHandler_01 before deal : sequence = 4, Event: 14--BatchEventHandler_02
BatchEventHandler_01 after  deal : Event: 14--BatchEventHandler_02--BatchEventHandler_01
可以看出每个SimpleHandler (implements EventHandler)都会处理同一条消息。另外还可以使用类似： 
disruptor.handleEventsWith(new SimpleHandler("BatchEventHandler_01"))
				.then(new SimpleHandler("BatchEventHandler_02"));
这样的方法来定义依赖关系，比如先执行哪个handler再执行哪个handler。
运行结果： 
Producer --- 0, event = 10
Producer --- 1, event = 11
BatchEventHandler_01 before deal : sequence = 0, Event: 10
BatchEventHandler_01 after  deal : Event: 10--BatchEventHandler_01
BatchEventHandler_01 before deal : sequence = 1, Event: 11
BatchEventHandler_01 after  deal : Event: 11--BatchEventHandler_01
BatchEventHandler_02 before deal : sequence = 0, Event: 10--BatchEventHandler_01
BatchEventHandler_02 after  deal : Event: 10--BatchEventHandler_01--BatchEventHandler_02
BatchEventHandler_02 before deal : sequence = 1, Event: 11--BatchEventHandler_01
BatchEventHandler_02 after  deal : Event: 11--BatchEventHandler_01--BatchEventHandler_02
Producer --- 2, event = 12
Producer --- 3, event = 13
BatchEventHandler_01 before deal : sequence = 2, Event: 12
BatchEventHandler_01 after  deal : Event: 12--BatchEventHandler_01
BatchEventHandler_01 before deal : sequence = 3, Event: 13
BatchEventHandler_01 after  deal : Event: 13--BatchEventHandler_01
BatchEventHandler_02 before deal : sequence = 2, Event: 12--BatchEventHandler_01
BatchEventHandler_02 after  deal : Event: 12--BatchEventHandler_01--BatchEventHandler_02
BatchEventHandler_02 before deal : sequence = 3, Event: 13--BatchEventHandler_01
BatchEventHandler_02 after  deal : Event: 13--BatchEventHandler_01--BatchEventHandler_02
Producer --- 4, event = 14
BatchEventHandler_01 before deal : sequence = 4, Event: 14
BatchEventHandler_01 after  deal : Event: 14--BatchEventHandler_01
BatchEventHandler_02 before deal : sequence = 4, Event: 14--BatchEventHandler_01
BatchEventHandler_02 after  deal : Event: 14--BatchEventHandler_01--BatchEventHandler_02
同样，还可以使用WorkerPool： 
	public static void work2() {
		ExecutorService executor = Executors.newFixedThreadPool(2);
		int ringBufferSize = 4; // RingBuffer 大小，必须是 2 的 N 次方；
		// 构造Disruptor
		Disruptor<SimpleEvent> disruptor = new Disruptor<SimpleEvent>(
				SimpleEvent.FACTORY, ringBufferSize, executor,
				ProducerType.SINGLE, new BlockingWaitStrategy());

		disruptor.handleExceptionsWith(new IgnoreExceptionHandler());

		disruptor.handleEventsWithWorkerPool(new SimpleHandler(
				"WorkEventHandler_01"),
				new SimpleHandler("WorkEventHandler_02"));

		RingBuffer<SimpleEvent> ringBuffer = disruptor.start();

		// // 获取生产者的位置信息
		SequenceBarrier sequenceBarrier = ringBuffer.newBarrier();

		// 生产者
		SimpleEventProducer producer = new SimpleEventProducer(ringBuffer);
		for (long i = 10; i < 15; i++) {
			producer.onData(String.valueOf(i));
		}
		disruptor.shutdown();
		executor.shutdown();
	}
运行结果： 
Producer --- 0, event = 10
Producer --- 1, event = 11
Producer --- 2, event = 12
Producer --- 3, event = 13
WorkEventHandler_02 before deal :  Event: 10
WorkEventHandler_01 before deal :  Event: 11
WorkEventHandler_02 after  deal :  Event: 10--WorkEventHandler_02
WorkEventHandler_01 after  deal :  Event: 11--WorkEventHandler_01
Producer --- 4, event = 14
WorkEventHandler_02 before deal :  Event: 12
WorkEventHandler_02 after  deal :  Event: 12--WorkEventHandler_02
WorkEventHandler_01 before deal :  Event: 13
WorkEventHandler_01 after  deal :  Event: 13--WorkEventHandler_01
WorkEventHandler_02 before deal :  Event: 14
WorkEventHandler_02 after  deal :  Event: 14--WorkEventHandler_02
zero__007
关注
专栏目录
【技术积累】SpringBoot+disruptor高性能队列
dylan的博客
08-15 1116
`队列`是在数据结构中是基础的数据类型，在编程开发经常使用的数据结构，java中的数据结构有很多种，我们常用到的可能使用阻塞队列（`BlockingQueue`），但是BlockingQueue队列性能相对于disruptor性能较低，应用场景较少，本文重点介绍BlockingQueue队列的性能瓶颈点和disruptor框架高性能的实现原理
spring集成disruptor
03-12
网上关于Disruptor的例子大部份是旧版本的， 其中集成spring的更少， 只好自已写个新版本简单的demo了。 该demo利用spring的定时器往Disruptor添加数据， 希望该demo能帮助到大家。
Disruptor 学习
yanghzaini的专栏
11-20 225
Martin Fowler在自己网站上写了一篇LMAX架构的文章，在文章中他介绍了LMAX是一种新型零售金融交易平台，它能够以很低的延迟产生大量交易。这个系统是建立在JVM平台上，其核心是一个业务逻辑处理器，它能够在一个线程里每秒处理6百万订单。业务逻辑处理器完全是运行在内存中，使用事件源驱动方式。业务逻辑处理器的核心是Disruptor。 Disruptor它是一个开源的并发框架，并获得2011...
Disruptor 图解
架构师尼恩
11-01 756
疯狂创客圈 经典图书 ： 《Netty Zookeeper Redis 高并发实战》 面试必备 + 面试必备 + 面试必备 【博客园总入口 】 疯狂创客圈 经典图书 ： 《SpringCloud、Nginx高并发核心编程》 大厂必备 + 大厂必备 + 大厂必备 【博客园总入口 】 入大厂+涨工资必备： 高并发【 亿级流量IM实战】 实战系列 【 SpringCloud Nginx秒杀】 实战系列 【博客园总入口 】 无锁编程（Lock Free）框架 系..
disruptor学习教程（一）helloWord
刘本龙的专栏
12-20 3616
一、什么是 Disruptor 从功能上来看，Disruptor 是实现了“队列”的功能，而且是一个有界队列。那么它的应用场景自然就是“生产者-消费者”模型的应用场合了。可以拿 JDK 的 BlockingQueue 做一个简单对比，以便更好地认识 Disruptor 是什么。我们知道 BlockingQueue 是一个 FIFO 队列，生产者(Producer)往队列里发布(publish)一项事
Disruptor学习
程序媛的一生
05-08 230
先把这几篇文章看了下 嗯。。。。 有点成效http://ifeve.com/disruptor/感觉好的点是ringbuffer 环形队列 其实是个数组 无锁  cas解决伪共享问题各种wait 策略
Disruptor的简单介绍与应用
01-07 1156
前言 最近工作比较忙，在工作项目中，看了很多人都自己实现了一套数据任务处理机制，个人感觉有点乱，且也方便他人的后续维护，所以想到了一种数据处理模式，即生产者、缓冲队列、消费者的模式来统一大家的实现逻辑。 下面时是对Disruptor基本使用的演示。使用中需要引入依赖 <dependency> <groupId>com.lmax</groupId> ...
disruptror的jar包和例子
01-09
同时，提供的"一个简单实用disruptor的例子"可以帮助我们更好地理解如何在实际项目中应用Disruptor。 这个例子可能包括以下几个部分： 1. 定义事件：首先，你需要创建一个代表业务逻辑的事件类，这个类将被放入环形...
转换为3GP,MP4的软件
10-28
3GP和MP4转换软件在日常生活中非常实用，尤其是对于经常在移动设备上看视频的用户。通过这些工具，用户可以在不牺牲太多质量的情况下，将大体积的视频文件压缩到适合手机存储和播放的大小，从而实现便捷的移动娱乐...
冬日魔幻之旅-seata+dubbo+nacos+springboot解决分布式事务的全网段唯一实践之作(上)
lifetragedy的专栏
01-22 8909
开篇 阿里把FESCAR开源了，开源后的名称叫SEATA。目前GIT上已经超1万3的星了。 可是笔者遍历全网段，无一篇是生产实用级说明同时GIT官网上的相关文档缺失以及Sample都太HelloWorld了，无法应用在真正的生产环境上。 于是笔者结合了在6，7年前那时在那个MQ年代来解决分布式事务的经验，结合这次的SEATA（最新一次COMMIT在2019年12月底）来讲一下最最新的也是目前...
spring与disruptor集成的简单示例
08-27
本篇文章主要介绍了spring与disruptor集成的简单示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Storm学习(一)Storm介绍
Java海洋
10-31 4685
场景 伴随着信息科技日新月异的发展，信息呈现出爆发式的膨胀，人们获取信息的途径也更加多样、更加便捷，同时对于信息的时效性要求也越来越高。举个搜索场景中的例子，当一个卖家发布了一条宝贝信息时，他希望的当然是这个宝贝马上就可以被卖家搜索出来、点击、购买啦，相反，如果这个宝贝要等到第二天或者更久才可以被搜出来，估计这个大哥就要骂娘了。再举一个推荐的例子，如果用户昨天在淘宝上买了一双袜子，今天想买一
Disruptor学习之路（一）
weixin_34087307的博客
12-17 142
2019独角兽企业重金招聘Python工程师标准>>> ...
Disruptor学习笔记：基本使用、核心概念和原理
hxt的博客
09-20 1584
Disruptor是英国外汇交易公司LMAX开发的一个高性能队列（系统内部的内存队列），研发的初衷是解决内存队列的延迟问题（在性能测试中发现竟然与I/O操作处于同样的数量级）。基于Disruptor开发的系统单线程能支撑每秒600万订单，2010年在QCon演讲后，获得了业界关注。2011年，企业应用软件专家Martin Fowler专门撰写长文介绍。同年它还获得了Oracle官方的Duke大奖 1、快速入门 1）、步骤 创建一个工厂Event类，用于创建Event类实例对象 需要有一个监听事件类，用于处
Disruptor学习总结（一）：Disruptor的使用
lang_programmer的博客
06-08 860
一、简介      Disruptor是一个生产者/消费者模式的框架，它有一个名字叫RingBuffer的容器。生产者生产数据，往RingBuffer上面装；消费者从RingBuffer上取数据，就像JDK中concurrent包的BlockingQueue一样，可以同时存取。但是Disruptor采用了无锁机制、批量消费等一系列优化策略，比BlockingQueue性能更优。至于它可以做什么，那就
disruptor学习笔记(一)
qq_37955980的博客
08-30 236
定义 实体类 package cn.fnst.comm.disruptor.event; /** * @author fanghc.fnst * @title: LongEvent * @projectName DisruptorDemo * @description: TODO Bean 类 * @date 2019/8/3012:03 */ public class Long...
【跟着中间件学技术：disruptor 源码学习】
最新发布
whatjeans的博客
10-05 367
disruptor是一个典型业务属性比较强的高性能中间件（生产消费者模式业务场景），阅读完大部分disruptor的源码后，真的感慨disruptor团队追求极致的专业和code精神，同时也是通过这一次的学习，让我更加了解如何应用disruptor以及如何设计高性能的接口打下坚实的基础，笔者认为disruptor的源码难点主要在于多消费者协调那块，只要把屏障和生产者的门禁之间的关系理清楚了，就差不多了更加了解如何应用disruptor，disruptor主要应用于高并发、低延迟、内存级别的生产、消费场景。
Disruptor学习总结（二）：Disruptor分析
lang_programmer的博客
06-08 610
一、RingBuffer相关      在上文中我们介绍了RingBuffer的结构，这里我们就不再赘述了。它比操作数组更快，因为不用删除对象，数据对象可以复用，但是我们还存在几个疑问。整个生产/消费环境是怎样协调的？RingBuffer如何防止数据覆盖？接下来，我们就这两个问题进行分析。1、生产/消费协调      当生产者和消费者都只有一个时，两个线程分别操作不同的指针（一读一写），此时不需要锁
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值