Disruptor笔记(三)-处理模式

常见模式：

1.UniCast a series of items between 1 publisher and 1 EventProcessor:一个publisher 一个eventprocessor

P1  - Publisher 1

RB  - RingBuffer

SB  - SequenceBarrier

EP1 -EventProcessor 1

代码：

 private final RingBuffer<ValueEvent> ringBuffer =
         new RingBuffer<ValueEvent>(ValueEvent.EVENT_FACTORY,
                                    new SingleThreadedClaimStrategy(BUFFER_SIZE),
                                    newYieldingWaitStrategy());
     private final SequenceBarrier sequenceBarrier = ringBuffer.newBarrier();
     private final ValueAdditionEventHandler handler = newValueAdditionEventHandler();
     private finalBatchEventProcessor<ValueEvent> batchEventProcessor = new BatchEventProcessor<ValueEvent>(ringBuffer, sequenceBarrier, handler);
     {
         ringBuffer.setGatingSequences(batchEventProcessor.getSequence());
 }

或 DSL写法

 Disruptor  disruptor = new Disruptor<TestEvent>(TestEvent.EVENT_FACTORY, executor,
                                              newSingleThreadedClaimStrategy(4),
                                              newBlockingWaitStrategy());
 private final ValueAdditionEventHandler handler = new ValueAdditionEventHandler();
 disruptor. handleEventsWith(handler);//
 disruptor.start();

2.Pipeline a series of messages

  P1  - Publisher 1

  RB  - RingBuffer

  SB1 - SequenceBarrier 1

  EP1 - EventProcessor 1

  SB2 - SequenceBarrier 2

  EP2 - EventProcessor 2

  SB3 - SequenceBarrier 3

  EP3 -EventProcessor 3

 private final RingBuffer<FunctionEvent> ringBuffer =
         new RingBuffer<FunctionEvent>(FunctionEvent.EVENT_FACTORY,
                                       new SingleThreadedClaimStrategy(BUFFER_SIZE),
                                       new YieldingWaitStrategy());

     private final SequenceBarrier stepOneSequenceBarrier = ringBuffer.newBarrier();
     private final FunctionEventHandler stepOneFunctionHandler = new FunctionEventHandler(FunctionStep.ONE);
     private final BatchEventProcessor<FunctionEvent> stepOneBatchProcessor =
         new BatchEventProcessor<FunctionEvent>(ringBuffer, stepOneSequenceBarrier, stepOneFunctionHandler);


     private final SequenceBarrier stepTwoSequenceBarrier = ringBuffer.newBarrier(stepOneBatchProcessor.getSequence());
     private final FunctionEventHandler stepTwoFunctionHandler = new FunctionEventHandler(FunctionStep.TWO);
     private final BatchEventProcessor<FunctionEvent> stepTwoBatchProcessor =
         new BatchEventProcessor<FunctionEvent>(ringBuffer, stepTwoSequenceBarrier, stepTwoFunctionHandler);


     private final SequenceBarrier stepThreeSequenceBarrier = ringBuffer.newBarrier(stepTwoBatchProcessor.getSequence());
     private final FunctionEventHandler stepThreeFunctionHandler = new FunctionEventHandler(FunctionStep.THREE);
     private final BatchEventProcessor<FunctionEvent> stepThreeBatchProcessor =
         new BatchEventProcessor<FunctionEvent>(ringBuffer, stepThreeSequenceBarrier, stepThreeFunctionHandler);
     {
         ringBuffer.setGatingSequences(stepThreeBatchProcessor.getSequence());
     }

 <pre name="code" class="java">Disruptor  disruptor = new Disruptor<TestEvent>(TestEvent.EVENT_FACTORY, executor,
                                              new SingleThreadedClaimStrategy(4),
                                              new BlockingWaitStrategy());
 private final FunctionEventHandler stepOneFunctionHandler = new FunctionEventHandler(FunctionStep.ONE);
 EventHandlerGroup< TestEvent > group = disruptor. handleEventsWith(stepOneFunctionHandler);

 private final FunctionEventHandler stepTwoFunctionHandler = new FunctionEventHandler(FunctionStep.TWO);

 private final FunctionEventHandler stepThreeFunctionHandler = new FunctionEventHandler(FunctionStep.THREE);
 disruptor.handleEventsWith(stepOneFunctionHandler);
 disruptor.after(stepOneFunctionHandler).handleEventsWith(stepTwoFunctionHandler);
 disruptor.after(stepTwoFunctionHandler).handleEventsWith(stepThreeFunctionHandler);

 或者
 Disruptor. handleEventsWith(stepOneFunctionHandler).then(stepTwoFunctionHandler).then(stepThreeFunctionHandler);
 disruptor.start();
 </pre><br>
 <br>
 <pre></pre>
 <p></p>
 <p>3.<strong>Multicast a series of messages to multiple EventProcessors</strong></p>
 <p><img src="http://hi.csdn.net/attachment/201203/8/0_1331177654ZLnL.gif" alt=""></p>
 <p>P1  - Publisher 1</p>
 <p align="left">RB  - RingBuffer</p>
 <p align="left">SB  -SequenceBarrier</p>
 <p align="left">EP1 - EventProcessor 1</p>
 <p align="left">EP2 - EventProcessor 2</p>
 <p>EP3 -EventProcessor 3</p>
 <p></p>
 <p></p>
 <pre name="code" class="java">private final RingBuffer<ValueEvent> ringBuffer =
         new RingBuffer<ValueEvent>(ValueEvent.EVENT_FACTORY,
                                    new SingleThreadedClaimStrategy(BUFFER_SIZE),
                                    new YieldingWaitStrategy());

     private final SequenceBarrier sequenceBarrier = ringBuffer.newBarrier();

     private final ValueMutationEventHandler[] handlers = new ValueMutationEventHandler[NUM_EVENT_PROCESSORS];
     {
         handlers[0] = new ValueMutationEventHandler(Operation.ADDITION);
         handlers[1] = new ValueMutationEventHandler(Operation.SUBTRACTION);
         handlers[2] = new ValueMutationEventHandler(Operation.AND);
     }

     private final BatchEventProcessor[] batchEventProcessors = new BatchEventProcessor[NUM_EVENT_PROCESSORS];
     {
         batchEventProcessors[0] = new BatchEventProcessor<ValueEvent>(ringBuffer, sequenceBarrier, handlers[0]);
         batchEventProcessors[1] = new BatchEventProcessor<ValueEvent>(ringBuffer, sequenceBarrier, handlers[1]);
         batchEventProcessors[2] = new BatchEventProcessor<ValueEvent>(ringBuffer, sequenceBarrier, handlers[2]);

         ringBuffer.setGatingSequences(batchEventProcessors[0].getSequence(),
                                       batchEventProcessors[1].getSequence(),
                                       batchEventProcessors[2].getSequence());
     }<strong>
 </strong></pre><pre name="code" class="java">Disruptor  disruptor = new Disruptor<TestEvent>(TestEvent.EVENT_FACTORY, executor,
                                              new SingleThreadedClaimStrategy(4),
                                              new BlockingWaitStrategy());
 private final FunctionEventHandler stepOneFunctionHandler = new FunctionEventHandler(FunctionStep.ONE);
 EventHandlerGroup< TestEvent > group = disruptor. handleEventsWith(stepOneFunctionHandler);

 private final FunctionEventHandler stepTwoFunctionHandler = new FunctionEventHandler(FunctionStep.TWO);

 private final FunctionEventHandler stepThreeFunctionHandler = new FunctionEventHandler(FunctionStep.THREE);

 disruptor. handleEventsWith(stepOneFunctionHandler ,stepTwoFunctionHandler,stepThreeFunctionHandler);
 disruptor.start();
 </pre><br>
 4.<strong>Replicate a message then fold back the results</strong>
 <p></p>
 <p><img src="http://hi.csdn.net/attachment/201203/8/0_1331177673MmKX.gif" alt=""><br>
 </p>
 <p> P1  - Publisher 1</p>
 <p style="font-weight:bold"></p>
 <p align="left"> RB  - RingBuffer</p>
 <p align="left"> SB1 - SequenceBarrier 1</p>
 <p align="left"> EP1 - EventProcessor 1</p>
 <p align="left"> EP2 - EventProcessor 2</p>
 <p align="left">SB2 - SequenceBarrier 2</p>
 <p>EP3 -EventProcessor 3</p>
 <pre name="code" class="java">private final RingBuffer<FizzBuzzEvent> ringBuffer =
         new RingBuffer<FizzBuzzEvent>(FizzBuzzEvent.EVENT_FACTORY,
                                       new SingleThreadedClaimStrategy(BUFFER_SIZE),
                                       new YieldingWaitStrategy());

     private final SequenceBarrier sequenceBarrier = ringBuffer.newBarrier();

     private final FizzBuzzEventHandler fizzHandler = new FizzBuzzEventHandler(FizzBuzzStep.FIZZ);
     private final BatchEventProcessor<FizzBuzzEvent> batchProcessorFizz =
         new BatchEventProcessor<FizzBuzzEvent>(ringBuffer, sequenceBarrier, fizzHandler);

     private final FizzBuzzEventHandler buzzHandler = new FizzBuzzEventHandler(FizzBuzzStep.BUZZ);
     private final BatchEventProcessor<FizzBuzzEvent> batchProcessorBuzz =
         new BatchEventProcessor<FizzBuzzEvent>(ringBuffer, sequenceBarrier, buzzHandler);

     private final SequenceBarrier sequenceBarrierFizzBuzz =
         ringBuffer.newBarrier(batchProcessorFizz.getSequence(), batchProcessorBuzz.getSequence());

     private final FizzBuzzEventHandler fizzBuzzHandler = new FizzBuzzEventHandler(FizzBuzzStep.FIZZ_BUZZ);
     private final BatchEventProcessor<FizzBuzzEvent> batchProcessorFizzBuzz =
             new BatchEventProcessor<FizzBuzzEvent>(ringBuffer, sequenceBarrierFizzBuzz, fizzBuzzHandler);
     {
         ringBuffer.setGatingSequences(batchProcessorFizzBuzz.getSequence());
 }
 </pre><br>
 <pre name="code" class="java">Disruptor  disruptor = new Disruptor<TestEvent>(TestEvent.EVENT_FACTORY, executor,
                                              new SingleThreadedClaimStrategy(4),
                                              new BlockingWaitStrategy());
 private final FunctionEventHandler stepOneFunctionHandler = new FunctionEventHandler(FunctionStep.ONE);
 EventHandlerGroup< TestEvent > group = disruptor. handleEventsWith(stepOneFunctionHandler);

 private final FunctionEventHandler stepTwoFunctionHandler = new FunctionEventHandler(FunctionStep.TWO);

 private final FunctionEventHandler stepThreeFunctionHandler = new FunctionEventHandler(FunctionStep.THREE);

 disruptor. handleEventsWith(stepOneFunctionHandler ,stepTwoFunctionHandler);
 disruptor.after(stepOneFunctionHandler, stepTwoFunctionHandler).handleEventsWith(stepThreeFunctionHandler);
 disruptor.start();
 </pre><br>
 5.<strong>Sequence a series of messages from multiple publishers</strong>
 <p></p>
 <p></p>
 <p style="font-weight:bold"><img src="http://hi.csdn.net/attachment/201203/8/0_13311776879is6.gif" alt=""><br>
 </p>
 <p style="font-weight:bold"> P1  - Publisher 1</p>
  P2  - Publisher 2<br>
  P3  - Publisher 3<br>
  RB  - RingBuffer<br>
  SB  - SequenceBarrier<br>
  EP1 - EventProcessor 1<br>
 <pre name="code" class="java">private final RingBuffer<ValueEvent> ringBuffer =
         new RingBuffer<ValueEvent>(ValueEvent.EVENT_FACTORY,
                                    new MultiThreadedLowContentionClaimStrategy(BUFFER_SIZE),
                                    new YieldingWaitStrategy());

     private final SequenceBarrier sequenceBarrier = ringBuffer.newBarrier();
     private final ValueAdditionEventHandler handler = new ValueAdditionEventHandler();
     private final BatchEventProcessor<ValueEvent> batchEventProcessor = new BatchEventProcessor<ValueEvent>(ringBuffer, sequenceBarrier, handler);
     private final ValuePublisher[] valuePublishers = new ValuePublisher[NUM_PUBLISHERS];
     {
         for (int i = 0; i < NUM_PUBLISHERS; i++)
         {
             valuePublishers[i] = new ValuePublisher(cyclicBarrier, ringBuffer, ITERATIONS / NUM_PUBLISHERS);
         }

         ringBuffer.setGatingSequences(batchEventProcessor.getSequence());
     }</pre><br>
 <br>
 <p></p>
 <p><strong><br>
 </strong></p>
 <br>
 <pre></pre>
 <pre></pre>
 <pre></pre>
 <pre></pre>
 <pre></pre>
 <pre></pre>
 <pre></pre>
 <pre></pre>
 <pre></pre>