disruptor实操作手册（一）

最新推荐文章于 2024-08-22 09:18:52 发布

全栈仁波切

最新推荐文章于 2024-08-22 09:18:52 发布

阅读量1.9k

点赞数

分类专栏： disruptor

本文链接：https://blog.csdn.net/fangxiaoji/article/details/46351759

版权

disruptor 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

disruptor是一个JAVA高性能并发框架，为什么快，原理是什么这类的话题百度有很多文档描述，这里不再重复。

本文的目的是把实际如何使用这一框架解决实际工作中遇到的问题尽可能的详细介绍。

本文使用的disruptor版本是3.3.2。

新建一个简单的disruptor工程。

一，构建工程

普通java工程，web工程都可以。这里实例使用java工程。

新建一个普通的maven工程，在pom文件里写入如下依赖

</span><dependency>
			<groupId>com.lmax</groupId>
			<artifactId>disruptor</artifactId>
			<version>3.3.2</version>
		</dependency>

工程build之后，即可在依赖里面看到disruptor的依赖包。

二，基本代码编写

2.1，首先先创建一个Event类。该类的作用就用来传递数据。如下：

public class LongEvent {
	private long value;
    public long getValue() { 
        return value; 
    } 
 
    public void setValue(long value) { 
        this.value = value; 
    } 
}

其实跟普通的java bean 没有什么区别，不用集成任何父类，也不需要实现任何接口。

2.2，创建EventFactory接口的实现类

import com.lmax.disruptor.EventFactory;

public class LongEventFactory implements EventFactory<LongEvent> {

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

}

如上所示，该类只需要实现一个方法，用来创建一个Event类并返回。

2.3，再来创建一个事件实现类，这里我们默认创建一个 EventHandler；

import java.util.Date;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.lmax.disruptor.EventHandler;

public class LongEventHandler implements EventHandler<LongEvent> {
	private static final Logger LOG =  LoggerFactory
			.getLogger(LongEventHandler.class);
	@Override
	public void onEvent(LongEvent longEvent, long sequence, boolean endOfBatch)
			throws Exception {
		boolean chk = true;
		long l = longEvent.getValue();
		LOG.info("开始处理" + l + "");
		Date dtStart = new Date();
		
		while(chk){
			Date dt = new Date();
			if(dt.getTime() - dtStart.getTime() >=20){
				chk = false;
				LOG.info("结束处理" + l + "");
			}
		}
	}
}

该类实现了EventHandler接口，在收到Event传递来的数据后，做了一个循环处理。

2.4，最后，我们来创建一个disruptor，来启动事件

public static void main(String[] args) throws InterruptedException {
		Executor executor = Executors.newCachedThreadPool();
		LongEventFactory factory = new LongEventFactory();
		int bufferSize = 1024;
		Disruptor<LongEvent> disruptor = new Disruptor<LongEvent>(factory,
				bufferSize, executor, ProducerType.SINGLE,
				new SleepingWaitStrategy());

		disruptor.handleEventsWith(new LongEventHandler() );
		disruptor.start();
		// 启动
		RingBuffer<LongEvent> ringBuffer = disruptor.getRingBuffer();
		LongEventProducer producer = new LongEventProducer(ringBuffer);
		for (long l = 0; l < 3; l++) {
			long sequence = ringBuffer.next();
			try {
				LongEvent event = ringBuffer.get(sequence);
				event.setValue(l);
			} finally {
				// 发布事件
				ringBuffer.publish(sequence);
			}
			Thread.sleep(1000);
		}
	}

运行下看看结果：

2015-06-04 23:18:12,146 INFO [com.xuyang.test.disruptor.LongEventHandler] batch开始处理0
2015-06-04 23:18:12,168 INFO [com.xuyang.test.disruptor.LongEventHandler] batch结束处理0
2015-06-04 23:18:13,145 INFO [com.xuyang.test.disruptor.LongEventHandler] batch开始处理1
2015-06-04 23:18:13,165 INFO [com.xuyang.test.disruptor.LongEventHandler] batch结束处理1
2015-06-04 23:18:14,149 INFO [com.xuyang.test.disruptor.LongEventHandler] batch开始处理2
2015-06-04 23:18:14,169 INFO [com.xuyang.test.disruptor.LongEventHandler] batch结束处理2

好了，一个简单的disruptor的工程到这里就已经完工了。