Disruptor简单应用

前段时间闲得蛋疼就尝试翻译了一下有关Disruptor的一些文章，第一次做这事，烂得自己也不忍回头去看了。。。

今天写日志看到那几篇文章，于是想写一个简单的例子，好让一些对Disruptor有兴趣但不是很明白的人更快的了解Disruptor的基本用法。

Disruptor使用起来非常简单，初始化－>启动消费者线程，然后每当生产者产生资源就往disruptor里放。

下面是一个接收短信状态报告的例子。

首先自定义一个Event类:

public class DeliveryReportEvent {
    private DeliveryReport deliveryReport;

    public DeliveryReport getDeliveryReport() {
        return deliveryReport;
    }

    public void setDeliveryReport(DeliveryReport deliveryReport) {
        this.deliveryReport = deliveryReport;
    }


    public final static EventFactory<DeliveryReportEvent> EVENT_FACTORY = new EventFactory<DeliveryReportEvent>() {
        public DeliveryReportEvent newInstance() {
            return new DeliveryReportEvent();
        }
    };
}

代码很简单，就是用来存放短信状态报告DeliveryReport类的，外加一个EventFactory，用来生成Event，也很简单。

然后写一个EventHandler类，用来处理Event，

public class DeliveryReportEventHandler implements EventHandler<DeliveryReportEvent> {
//    private static DeliveryReportRepository repository = new DeliveryReportRepository();
    public void onEvent(DeliveryReportEvent event, long sequence,
            boolean endOfBatch) throws Exception {
        System.out.println(event.getDeliveryReport().getMessageId());
//        repository.updateDeliveryReport(event.getDeliveryReport());
    }
}

三个参数，event就是生产者向Disruptor发布资源生产的事件，sequence是这个事件在ringbuffer中的序列号，endOfBatch指明该事件是不是ringbuffer中的最后一个事件。

在onEvent方法里处理消费者要做的事。本例直接打印状态报告ID或是更新数据库中的状态报告。

在这里我写了一个辅助类：

public class DisruptorHelper {
    /**
     * ringbuffer容量，最好是2的N次方
     */
    private static final int BUFFER_SIZE = 1024 * 8;
    private RingBuffer<DeliveryReportEvent> ringBuffer;
    private SequenceBarrier sequenceBarrier;
    private DeliveryReportEventHandler handler;
    private BatchEventProcessor<DeliveryReportEvent> batchEventProcessor;
    private  static DisruptorHelper instance;
    private static boolean inited = false;
    private DisruptorHelper(){
        ringBuffer = new RingBuffer<DeliveryReportEvent>(
                DeliveryReportEvent.EVENT_FACTORY, new SingleThreadedClaimStrategy(
                        BUFFER_SIZE), new YieldingWaitStrategy());
        sequenceBarrier = ringBuffer.newBarrier();
        handler = new DeliveryReportEventHandler();
        batchEventProcessor = new BatchEventProcessor<DeliveryReportEvent>(
                    ringBuffer, sequenceBarrier, handler);
        ringBuffer.setGatingSequences(batchEventProcessor
                .getSequence());
    }

    public static void initAndStart(){
        instance = new DisruptorHelper();
        new Thread(instance.batchEventProcessor).start();
        inited = true;
    }

    public static void shutdown(){
        if(!inited){
            throw new RuntimeException("Disruptor还没有初始化！");
        }
        instance.shutdown0();
    }

    private void shutdown0(){
        batchEventProcessor.halt();
    }
    private void produce0(DeliveryReport deliveryReport) {
        //获取下一个序列号
        long sequence = ringBuffer.next();
        //将状态报告存入ringBuffer的该序列号中
        ringBuffer.get(sequence).setDeliveryReport(deliveryReport);
        //通知消费者该资源可以消费
        ringBuffer.publish(sequence);
    }

    /**
     * 将状态报告放入资源队列，等待处理
     * @param deliveryReport
     */
    public static void produce(DeliveryReport deliveryReport) {
        if(!inited){
            throw new RuntimeException("Disruptor还没有初始化！");
        }
        instance.produce0(deliveryReport);
    }
}

哈哈，因为本例的initAndStart/shutdown方法是在一个loadonstartup的servlet中的init/destory方法里调用，所以就不加synchronized了，执行前也不判断inited是否为true了。

最后是生产者调用的方法，在接收短信状态报告的webservice里：

public void NotifySmsDeliveryReport(DeliveryReport deliveryReport) {
...
...
//向disruptor发布资源
DisruptorHelper.produce(deliveryReport);
}

关于disruptor的性能，可以去官网查看测试数据。也可以从官方svn检出代码，自己运行一下src/perf里的性能测试方法，

 

本例用到的包只有一个disruptor-2.7.1.jar，

<dependency>
  <groupId>com.googlecode.disruptor</groupId>
  <artifactId>disruptor</artifactId>

  <version>2.7.1</version>
</dependency>