How to use

com.lmax.disruptor.BatchEventProcessor

constructor

  @Override
  public EventProcessor createEventProcessor(
    final RingBuffer<TestEvent> ringBuffer, final Sequence[] barrierSequences)
  {
    assertEquals("Should not have had any barrier sequences", 0, barrierSequences.length);
    return new BatchEventProcessor<TestEvent>(
      disruptor.getRingBuffer(), ringBuffer.newBarrier(
      barrierSequences), eventHandler);
  }
});

  @Override
  public EventProcessor createEventProcessor(
    final RingBuffer<TestEvent> ringBuffer, final Sequence[] barrierSequences)
  {
    assertSame("Should have had a barrier sequence", 1, barrierSequences.length);
    return new BatchEventProcessor<TestEvent>(
      disruptor.getRingBuffer(), ringBuffer.newBarrier(
      barrierSequences), eventHandler);
  }
});

  @Override
  public EventProcessor createEventProcessor(
    RingBuffer<TestEvent> ringBuffer, Sequence[] barrierSequences)
  {
    return new BatchEventProcessor<TestEvent>(
      ringBuffer, ringBuffer.newBarrier(barrierSequences), new SleepingEventHandler());
  }
};

@Test(expected = NullPointerException.class)
public void shouldThrowExceptionOnSettingNullExceptionHandler()
{
  final BatchEventProcessor<StubEvent> batchEventProcessor = new BatchEventProcessor<StubEvent>(
    ringBuffer, sequenceBarrier, new ExceptionEventHandler());
  batchEventProcessor.setExceptionHandler(null);
}

EventHandlerGroup<T> createEventProcessors(
  final Sequence[] barrierSequences,
  final EventHandler<? super T>[] eventHandlers)
{
  checkNotStarted();
  final Sequence[] processorSequences = new Sequence[eventHandlers.length];
  final SequenceBarrier barrier = ringBuffer.newBarrier(barrierSequences);
  for (int i = 0, eventHandlersLength = eventHandlers.length; i < eventHandlersLength; i++)
  {
    final EventHandler<? super T> eventHandler = eventHandlers[i];
    final BatchEventProcessor<T> batchEventProcessor =
      new BatchEventProcessor<>(ringBuffer, barrier, eventHandler);
    if (exceptionHandler != null)
    {
      batchEventProcessor.setExceptionHandler(exceptionHandler);
    }
    consumerRepository.add(batchEventProcessor, eventHandler, barrier);
    processorSequences[i] = batchEventProcessor.getSequence();
  }
  updateGatingSequencesForNextInChain(barrierSequences, processorSequences);
  return new EventHandlerGroup<>(this, consumerRepository, processorSequences);
}

@Test
public void shouldCallExceptionHandlerOnUncaughtException()
  throws Exception
{
  CountDownLatch exceptionLatch = new CountDownLatch(1);
  LatchExceptionHandler latchExceptionHandler = new LatchExceptionHandler(exceptionLatch);
  final BatchEventProcessor<StubEvent> batchEventProcessor = new BatchEventProcessor<StubEvent>(
    ringBuffer, sequenceBarrier, new ExceptionEventHandler());
  ringBuffer.addGatingSequences(batchEventProcessor.getSequence());
  batchEventProcessor.setExceptionHandler(latchExceptionHandler);
  Thread thread = new Thread(batchEventProcessor);
  thread.start();
  ringBuffer.publish(ringBuffer.next());
  assertTrue(exceptionLatch.await(2, TimeUnit.SECONDS));
  batchEventProcessor.halt();
  thread.join();
}

@Test
public void shouldCallMethodsInLifecycleOrderForBatch()
  throws Exception
{
  CountDownLatch eventLatch = new CountDownLatch(3);
  LatchEventHandler eventHandler = new LatchEventHandler(eventLatch);
  final BatchEventProcessor<StubEvent> batchEventProcessor = new BatchEventProcessor<StubEvent>(
    ringBuffer, sequenceBarrier, eventHandler);
  ringBuffer.addGatingSequences(batchEventProcessor.getSequence());
  ringBuffer.publish(ringBuffer.next());
  ringBuffer.publish(ringBuffer.next());
  ringBuffer.publish(ringBuffer.next());
  Thread thread = new Thread(batchEventProcessor);
  thread.start();
  assertTrue(eventLatch.await(2, TimeUnit.SECONDS));
  batchEventProcessor.halt();
  thread.join();
}

new BatchEventProcessor<StubEvent>(
  ringBuffer, sequenceBarrier, new LoopbackEventHandler());

@Test
public void shouldSupportCustomProcessorsAsDependencies()
  throws Exception
{
  RingBuffer<TestEvent> ringBuffer = disruptor.getRingBuffer();
  final DelayedEventHandler delayedEventHandler = createDelayedEventHandler();
  CountDownLatch countDownLatch = new CountDownLatch(2);
  EventHandler<TestEvent> handlerWithBarrier = new EventHandlerStub<TestEvent>(countDownLatch);
  final BatchEventProcessor<TestEvent> processor =
    new BatchEventProcessor<TestEvent>(ringBuffer, ringBuffer.newBarrier(), delayedEventHandler);
  disruptor.handleEventsWith(processor).then(handlerWithBarrier);
  ensureTwoEventsProcessedAccordingToDependencies(countDownLatch, delayedEventHandler);
}

@Test
public void should()
  throws Exception
{
  RingBuffer<TestEvent> rb = disruptor.getRingBuffer();
  BatchEventProcessor<TestEvent> b1 = new BatchEventProcessor<TestEvent>(
    rb, rb.newBarrier(), new SleepingEventHandler());
  EventProcessorFactory<TestEvent> b2 = new EventProcessorFactory<TestEvent>()
  {
    @Override
    public EventProcessor createEventProcessor(
      RingBuffer<TestEvent> ringBuffer, Sequence[] barrierSequences)
    {
      return new BatchEventProcessor<TestEvent>(
        ringBuffer, ringBuffer.newBarrier(barrierSequences), new SleepingEventHandler());
    }
  };
  disruptor.handleEventsWith(b1).then(b2);
  disruptor.start();
}

simpleParserStage = new BatchEventProcessor<MessageEvent>(disruptorMsgBuffer,
  sequenceBarrier,
  new SimpleParserStage(logContext));
sinkStoreStage = new BatchEventProcessor<MessageEvent>(disruptorMsgBuffer,
  sinkSequenceBarrier,
  new SinkStoreStage());

new BatchEventProcessor<StubEvent>(ringBuffer, ringBuffer.newBarrier(), handler1);
new BatchEventProcessor<StubEvent>(ringBuffer, ringBuffer.newBarrier(processor1.getSequence()), handler2);

@Test
public void shouldReportProgressByUpdatingSequenceViaCallback()
  throws Exception
{
  final RingBuffer<StubEvent> ringBuffer = createMultiProducer(StubEvent.EVENT_FACTORY, 16);
  final SequenceBarrier sequenceBarrier = ringBuffer.newBarrier();
  final SequenceReportingEventHandler<StubEvent> handler = new TestSequenceReportingEventHandler();
  final BatchEventProcessor<StubEvent> batchEventProcessor = new BatchEventProcessor<StubEvent>(
    ringBuffer, sequenceBarrier, handler);
  ringBuffer.addGatingSequences(batchEventProcessor.getSequence());
  Thread thread = new Thread(batchEventProcessor);
  thread.setDaemon(true);
  thread.start();
  assertEquals(-1L, batchEventProcessor.getSequence().get());
  ringBuffer.publish(ringBuffer.next());
  callbackLatch.await();
  assertEquals(0L, batchEventProcessor.getSequence().get());
  onEndOfBatchLatch.countDown();
  assertEquals(0L, batchEventProcessor.getSequence().get());
  batchEventProcessor.halt();
  thread.join();
}

final BatchEventProcessor p1 = new BatchEventProcessor<>(dp, barrier, h1);
  final BatchEventProcessor p2 = new BatchEventProcessor<>(dp, barrier, h2);
  Thread t2 = new Thread(p2);
  t2.start();
  final BatchEventProcessor p2 = new BatchEventProcessor<>(dp, barrier, h2);
  Thread t2 = new Thread(p2);
  t2.start();

@Test
public void shouldSupportHandlersAsDependenciesToCustomProcessors()
  throws Exception
{
  final DelayedEventHandler delayedEventHandler = createDelayedEventHandler();
  disruptor.handleEventsWith(delayedEventHandler);
  RingBuffer<TestEvent> ringBuffer = disruptor.getRingBuffer();
  CountDownLatch countDownLatch = new CountDownLatch(2);
  EventHandler<TestEvent> handlerWithBarrier = new EventHandlerStub<TestEvent>(countDownLatch);
  final SequenceBarrier sequenceBarrier = disruptor.after(delayedEventHandler).asSequenceBarrier();
  final BatchEventProcessor<TestEvent> processor =
    new BatchEventProcessor<TestEvent>(ringBuffer, sequenceBarrier, handlerWithBarrier);
  disruptor.handleEventsWith(processor);
  ensureTwoEventsProcessedAccordingToDependencies(countDownLatch, delayedEventHandler);
}

@Test
public void shouldSupportCustomProcessorsAndHandlersAsDependencies() throws Exception
{
  final DelayedEventHandler delayedEventHandler1 = createDelayedEventHandler();
  final DelayedEventHandler delayedEventHandler2 = createDelayedEventHandler();
  disruptor.handleEventsWith(delayedEventHandler1);
  RingBuffer<TestEvent> ringBuffer = disruptor.getRingBuffer();
  CountDownLatch countDownLatch = new CountDownLatch(2);
  EventHandler<TestEvent> handlerWithBarrier = new EventHandlerStub<TestEvent>(countDownLatch);
  final SequenceBarrier sequenceBarrier = disruptor.after(delayedEventHandler1).asSequenceBarrier();
  final BatchEventProcessor<TestEvent> processor =
    new BatchEventProcessor<TestEvent>(ringBuffer, sequenceBarrier, delayedEventHandler2);
  disruptor.after(delayedEventHandler1).and(processor).handleEventsWith(handlerWithBarrier);
  ensureTwoEventsProcessedAccordingToDependencies(countDownLatch, delayedEventHandler1, delayedEventHandler2);
}

@Test
public void shouldAddEventProcessorsAfterPublishing() throws Exception
{
  RingBuffer<TestEvent> rb = disruptor.getRingBuffer();
  BatchEventProcessor<TestEvent> b1 = new BatchEventProcessor<TestEvent>(
    rb, rb.newBarrier(), new SleepingEventHandler());
  BatchEventProcessor<TestEvent> b2 = new BatchEventProcessor<TestEvent>(
    rb, rb.newBarrier(b1.getSequence()), new SleepingEventHandler());
  BatchEventProcessor<TestEvent> b3 = new BatchEventProcessor<TestEvent>(
    rb, rb.newBarrier(b2.getSequence()), new SleepingEventHandler());
  assertThat(b1.getSequence().get(), is(-1L));
  assertThat(b2.getSequence().get(), is(-1L));
  assertThat(b3.getSequence().get(), is(-1L));
  rb.publish(rb.next());
  rb.publish(rb.next());
  rb.publish(rb.next());
  rb.publish(rb.next());
  rb.publish(rb.next());
  rb.publish(rb.next());
  disruptor.handleEventsWith(b1, b2, b3);
  assertThat(b1.getSequence().get(), is(5L));
  assertThat(b2.getSequence().get(), is(5L));
  assertThat(b3.getSequence().get(), is(5L));
}

EventHandlerGroup<T> createEventProcessors(
  final Sequence[] barrierSequences,
  final EventHandler<? super T>[] eventHandlers)
{
  checkNotStarted();
  final Sequence[] processorSequences = new Sequence[eventHandlers.length];
  final SequenceBarrier barrier = ringBuffer.newBarrier(barrierSequences);
  for (int i = 0, eventHandlersLength = eventHandlers.length; i < eventHandlersLength; i++)
  {
    final EventHandler<? super T> eventHandler = eventHandlers[i];
    final BatchEventProcessor<T> batchEventProcessor =
      new BatchEventProcessor<>(ringBuffer, barrier, eventHandler);
    if (exceptionHandler != null)
    {
      batchEventProcessor.setExceptionHandler(exceptionHandler);
    }
    consumerRepository.add(batchEventProcessor, eventHandler, barrier);
    processorSequences[i] = batchEventProcessor.getSequence();
  }
  updateGatingSequencesForNextInChain(barrierSequences, processorSequences);
  return new EventHandlerGroup<>(this, consumerRepository, processorSequences);
}

public void subscribe(URI uri, ChannelConnection connection) {
  if (ringBuffer == null) {
    subscribers.put(uri, connection);
  } else {
    // ring buffer already started, add dynamically
    boolean channelEvent = EventHandlerHelper.isChannelEvent(connection);
    ChannelEventHandler handler = new ChannelEventHandler(connection, channelEvent);
    SequenceBarrier barrier = ringBuffer.newBarrier();
    BatchEventProcessor<RingBufferEvent> processor = new BatchEventProcessor<>(ringBuffer, barrier, handler);
    Sequence sequence = processor.getSequence();
    sequenceGroup.addWhileRunning(ringBuffer, sequence);
    executorService.execute(processor);
    sequences.put(uri, sequence);
    subscribers.put(uri, connection);
  }
}

public DisruptorQueueStorage() {
  this.logEntryRingBuffer = RingBuffer.createMultiProducer(LogEntryEvent.EVENT_FACTORY, LOGENTRY_BUFFER_SIZE, new SleepingWaitStrategy());
  this.logEntrySequenceBarrier = logEntryRingBuffer.newBarrier();
  this.logEntryEventProcessor = new BatchEventProcessor<LogEntryEvent>(logEntryRingBuffer, logEntrySequenceBarrier, new LogEntryEventHandler());
}