Trisha gee concurrentprogrammingusingthedisruptor

Concurrent Programming
Using The Disruptor
Trisha Gee, Senior Developer at LMAX

The Disruptor?

• Open Source
• Message Passing

Example 1:
One Publisher, One Processor

First, create your Event
public class SimpleEvent {
public static final EventFactory<SimpleEvent> EVENT_FACTORY = new
SimpleEventFactory();
private String value;

public String getValue() {
return value;
}

public void setValue(String value) {
this.value = value;
}

@Override
public String toString() {
return "SimpleEvent{" +
"value='" + value + ''' +
'}';
}

private static class SimpleEventFactory implements EventFactory<SimpleEvent> {
public SimpleEvent newInstance() {
return new SimpleEvent();
}
}
}

Then create your
EventHandler
public class SimpleEventHandler implements EventHandler<SimpleEvent>{
private List<String> valuesSeen = new ArrayList<String>();

@Override
public void onEvent(final SimpleEvent event,
final long sequence,
final boolean endOfBatch) throws Exception {
valuesSeen.add(event.getValue());
}

public int getNumberOfEventsProcessed() {
return valuesSeen.size();
}

public List<String> getEventValuesSeen() {
return valuesSeen;
}
}

Then wire it all together
final RingBuffer<SimpleEvent> ringBuffer =
new RingBuffer<SimpleEvent>(SimpleEvent.EVENT_FACTORY,
new SingleThreadedClaimStrategy(RING_BUFFER_SIZE),
new YieldingWaitStrategy());

final SimpleEventHandler eventHandler = new SimpleEventHandler();

final BatchEventProcessor<SimpleEvent> eventProcessor =
new BatchEventProcessor<SimpleEvent>(ringBuffer,
ringBuffer.newBarrier(),
eventHandler);

eventHandler.setSequence(eventProcessor.getSequence());
ringBuffer.setGatingSequences(eventProcessor.getSequence());

Example 2:
One Publisher, Three Processors

A more complicated
Event
public class WriteTrackingEvent {
public static final EventFactory<> EVENT_FACTORY =
new MyEventFactory();

private Values redValues = new Values();
private Values blueValues = new Values();
private Result result;

public void setResult(Result result) {
this.result = result;
}

private static final class MyEventFactory implements
EventFactory<WriteTrackingEvent> {
public WriteTrackingEvent newInstance() {
return new WriteTrackingEvent();
}
}
}

...a couple of
EventHandlers
public class BlueEventHandler implements
EventHandler<WriteTrackingEvent> {
@Override
public void onEvent(WriteTrackingEvent event, long sequence,
final boolean endOfBatch) throws Exception {
event.getBlueValues().setTime(System.currentTimeMillis());
System.out.println("blue: " + event);
}
}
public class RedEventHandler implements
EventHandler<WriteTrackingEvent> {
@Override
boolean endOfBatch) throws Exception {
event.getRedValues().setTime(System.currentTimeMillis());
System.out.println("red: " + event);
}
}

...a ﬁnal EventHandler
public class SummaryEventHandler implements EventHandler<WriteTrackingEvent> {
private int numberOfEventsProcessed = 0;

boolean endOfBatch) throws Exception {
numberOfEventsProcessed++;
final long blueTimestamp = event.getBlueValues().getTimestamp();
final long redTimestamp = event.getRedValues().getTimestamp();

WriteTrackingEvent.Result result;
if (blueTimestamp < redTimestamp) {
result = WriteTrackingEvent.Result.BLUE_FIRST;
} else if (redTimestamp < blueTimestamp) {
result = WriteTrackingEvent.Result.RED_FIRST;
} else {
result = WriteTrackingEvent.Result.SAME_TIME;
}

event.setResult(result);
System.out.println("final: " + event);
}

public int getNumberOfEventsProcessed() {
return numberOfEventsProcessed;
}
}

Put it all together, and what
have you got?
RingBuffer<WriteTrackingEvent> ringBuffer = new
RingBuffer<WriteTrackingEvent>(WriteTrackingEvent.EVENT_FACTORY,
new SingleThreadedClaimStrategy(RING_BUFFER_SIZE),

SequenceBarrier colourSequenceBarrier = ringBuffer.newBarrier();
BatchEventProcessor<WriteTrackingEvent> redEventProcessor = new
BatchEventProcessor<WriteTrackingEvent>(ringBuffer, colourSequenceBarrier,
new RedEventHandler());

BatchEventProcessor<WriteTrackingEvent> blueEventProcessor = new
BatchEventProcessor<WriteTrackingEvent>(ringBuffer, colourSequenceBarrier,
new BlueEventHandler());

SequenceBarrier summarySequenceBarrier =
ringBuffer.newBarrier(redEventProcessor.getSequence(),
blueEventProcessor.getSequence());
BatchEventProcessor<WriteTrackingEvent> finalEventProcessor = new
BatchEventProcessor<WriteTrackingEvent>(ringBuffer, summarySequenceBarrier,
new SummaryEventHandler());

ringBuffer.setGatingSequences(finalEventProcessor.getSequence());

What’s all that gubbins
on the RingBuffer?
RingBuffer<WriteTrackingEvent> ringBuffer = new
Buffer<WriteTrackingEvent>(WriteTrackingEvent.EVENT_FA
new SingleThreadedClaimStrategy(RING_B

Is that it?

• Multiple publishers
• Different EventHandlers
• The Wizard

More Information

• Blog
• Wiki
• Presentations

Q&A

• We are hiring!
• careers@lmax.com

Trisha gee concurrentprogrammingusingthedisruptor

More Related Content

What's hot (19)

Similar to Trisha gee concurrentprogrammingusingthedisruptor (20)

Recently uploaded (20)

Trisha gee concurrentprogrammingusingthedisruptor