disruptor第五弹(横行)

前言：原理讲了那么多，现在我们来实现下

package com.lmax.disruptor.test;

import com.lmax.disruptor.*;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.dsl.ProducerType;

import java.util.concurrent.ThreadFactory;

/**
 * @Auther: miaomiao
 * @Date: 2019-09-20 10:02
 * @Description:
 */
public class DisruptorTest {

    /**
     * 消息事件类
     */
    public static class MessageEvent{
        /**
         * 原始消息
         */
        private String message;

        public String getMessage() {
            return message;
        }

        public void setMessage(String message) {
            this.message = message;
        }
    }


    /**
     * 消息事件工厂类
     */
    public static class MessageEventFactory implements EventFactory<MessageEvent> {
        @Override
        public MessageEvent newInstance() {
            return new MessageEvent();
        }
    }


    /**
     * 消息转换类，负责将消息转换为事件
     */
    public static class MessageEventTranslator implements EventTranslatorOneArg<MessageEvent,String> {
        @Override
        public void translateTo(MessageEvent messageEvent, long l, String s) {
            messageEvent.setMessage(s);
        }
    }

    /**
     * 消费者线程工厂类
     */
    public static class MessageThreadFactory implements ThreadFactory {
        @Override
        public Thread newThread(Runnable r) {
            return new Thread(r,"Simple Disruptor Test Thread");
        }
    }

    /**
     * 消息事件处理类，这里只打印消息
     */
    public static class MessageEventHandler1 implements EventHandler<MessageEvent> {
        @Override
        public void onEvent(MessageEvent messageEvent, long sequence, boolean endOfBatch) throws Exception {
            System.out.println("1：消费："+messageEvent.getMessage());
        }
    } /**
     * 消息事件处理类，这里只打印消息
     */
    public static class MessageEventHandler2 implements EventHandler<MessageEvent> {
        @Override
        public void onEvent(MessageEvent messageEvent, long sequence, boolean endOfBatch) throws Exception {
            System.out.println("2：消费："+messageEvent.getMessage());
        }
    } 
    public static class MessageEventHandler3 implements EventHandler<MessageEvent> {
        @Override
        public void onEvent(MessageEvent messageEvent, long sequence, boolean endOfBatch) throws Exception {
            System.out.println("3：消费："+messageEvent.getMessage());
        }
    }

    public static class MessageEventHandler4 implements EventHandler<MessageEvent> {
        @Override
        public void onEvent(MessageEvent messageEvent, long sequence, boolean endOfBatch) throws Exception {
            System.out.println("4：消费："+messageEvent.getMessage());
        }
    }

    /**
     * 异常处理类
     */
    public static class MessageExceptionHandler implements ExceptionHandler<MessageEvent> {
        @Override
        public void handleEventException(Throwable ex, long sequence, MessageEvent event) {
            ex.printStackTrace();
        }

        @Override
        public void handleOnStartException(Throwable ex) {
            ex.printStackTrace();

        }

        @Override
        public void handleOnShutdownException(Throwable ex) {
            ex.printStackTrace();

        }
    }

    /**
     * 消息生产者类
     */
    public static class MessageEventProducer{
        private RingBuffer<MessageEvent> ringBuffer;

        public MessageEventProducer(RingBuffer<MessageEvent> ringBuffer) {
            this.ringBuffer = ringBuffer;
        }

        /**
         * 将接收到的消息输出到ringBuffer
         * @param message
         */
        public void onData(String message){
            EventTranslatorOneArg<MessageEvent,String> translator = new MessageEventTranslator();
            ringBuffer.publishEvent(translator,message);
        }
    }

 
}

 

 

public static void main(String[] args) throws InterruptedException {
        //必须是2的N次方
        int ringBufferSize = 32;
        Disruptor<MessageEvent> disruptor = new Disruptor<MessageEvent>(new MessageEventFactory(),ringBufferSize,new MessageThreadFactory(), ProducerType.SINGLE,new BlockingWaitStrategy());
        disruptor.handleEventsWith(new MessageEventHandler1(),new MessageEventHandler2()).then(new MessageEventHandler3());
        disruptor.setDefaultExceptionHandler(new MessageExceptionHandler());
        RingBuffer<MessageEvent> ringBuffer = disruptor.start();
        MessageEventProducer producer = new MessageEventProducer(ringBuffer);
        for (int i = 0; i <35 ; i++) {
            producer.onData(i+"xixi");
        }

        disruptor.shutdown();
    }

主要就是下面这句话，两个消费者一起消费，消费完之后，再丢给下一个消费者 （这里是 MessageEventHandler3）

 disruptor.handleEventsWith(new MessageEventHandler1(),new MessageEventHandler2()).then(new MessageEventHandler3());

 

 

 disruptor.handleEventsWith(new MessageEventHandler1(),new MessageEventHandler2(),new MessageEventHandler3()); 

 

disruptor.handleEventsWith(new MessageEventHandler1()).then(new MessageEventHandler2()).then(new MessageEventHandler3());

 

disruptor.handleEventsWith(new MessageEventHandler1()).then(new MessageEventHandler2()).then(new MessageEventHandler3());
        disruptor.handleEventsWith(new MessageEventHandler1()).then(new MessageEventHandler2()).then(new MessageEventHandler3());

 

 public static class MessageEventHandlerWork1 implements WorkHandler<MessageEvent>{

        @Override
        public void onEvent(MessageEvent event) throws Exception {
            System.out.println("1：消费："+event.getMessage());
        }
    }
    public static class MessageEventHandlerWork2 implements WorkHandler<MessageEvent>{

        @Override
        public void onEvent(MessageEvent event) throws Exception {
            System.out.println("2：消费："+event.getMessage());
        }
    }
    public static class MessageEventHandlerWork3 implements WorkHandler<MessageEvent>{

        @Override
        public void onEvent(MessageEvent event) throws Exception {
            System.out.println("3：消费："+event.getMessage());
        }
    }
    public static class MessageEventHandlerWork4 implements WorkHandler<MessageEvent>{

        @Override
        public void onEvent(MessageEvent event) throws Exception {
            System.out.println("4：消费："+event.getMessage());
        }
    }
public static void main(String[] args) throws InterruptedException {
        //必须是2的N次方
        int ringBufferSize = 32;
        Disruptor<MessageEvent> disruptor = new Disruptor<MessageEvent>(new MessageEventFactory(),ringBufferSize,new MessageThreadFactory(), ProducerType.SINGLE,new BlockingWaitStrategy());
 
        disruptor.handleEventsWithWorkerPool(new MessageEventHandlerWork1(),new MessageEventHandlerWork2());
        disruptor.handleEventsWithWorkerPool(new MessageEventHandlerWork3(),new MessageEventHandlerWork4());
        disruptor.setDefaultExceptionHandler(new MessageExceptionHandler());
        RingBuffer<MessageEvent> ringBuffer = disruptor.start();
        MessageEventProducer producer = new MessageEventProducer(ringBuffer);
        for (int i = 0; i <10 ; i++) {
            producer.onData(i+"xixi");
        }

        disruptor.shutdown();
    }

这种消费方式就是，1个c1和c2是一个整体。比如现在有20条数据，c1和c2一起消费20条，不是之前c1消费20条，c2消费20条

 

之前消费者是 BatchEventProcessor，他有自己的消费指针，相当于rocketmq的轮询消费，生产者生产多少，大家都消费多少

但现在消费者是  WorkProcessor ，他们有个共同的父亲（共同的消费指针）WorkerPool里。所以现在是共同消费，相当于rocketmq的负载均衡模式，你消费了，我就不消费。

 

disruptor.handleEventsWithWorkerPool(new MessageEventHandlerWork1(),new MessageEventHandlerWork2()).thenHandleEventsWithWorkerPool(new MessageEventHandlerWork3(),new MessageEventHandlerWork4());

注意这里是 thenHandleEventsWithWorkerPool  不是then。