Welcome!

Microservices Expo Authors: Liz McMillan, VictorOps Blog, Cynthia Dunlop, Carmen Gonzalez, Karyn Jeffery

Related Topics: Java IoT, Industrial IoT, Microservices Expo, Eclipse, IoT User Interface, Apache

Java IoT: Article

The Disruptor Framework: A Concurrency Framework for Java

Rediscovering the Producer-Consumer Model with the Disruptor

Let's start with the basic question: What is the disruptor? The disruptor is a concurrency framework for Java that allows data sharing between threads. The age old way of coding a producer-consumer model is to use a queue as the buffer area between the producer and the consumer, where the producer adds data objects to the queue, which are in turn processed by the consumer. However, such a model does not work well at the hardware level and ends up being highly inefficient. The disruptor in its simplest form replaces the queue with a data structure known as the ‘ring buffer'. Which brings us to the next question, what is the ring buffer? The ring buffer is an array of fixed length (which must be a power of 2), it's circular and wraps. This data structure is at the core of what makes the disruptor super fast.

Let's explore a simple everyday scenario in enterprise architectures. A producer (let's call it the publisher) creates data and stores it in the queue. Two immediate consumers (let's call them fooHandler and barHandler) consume the data and make updates to it. Once these 2 processors are done with a piece of data, it is then passed on to a third consumer (let's call it fooBarHandler) for further processing. In a concurrent processing system using legacy techniques, coding this architecture would involve a crisscross of queues and numerous concurrency challenges, such as dealing with locks, CAS, write contention, etc. The disruptor on the other hand immensely simplifies such a scenario by providing a simple API for creating the producer, consumers and ring buffer, which in turn relieve the developer of all concerns surrounding handling concurrency and doing so in an efficient manner. We shall now explore how the disruptor works its magic and provides a reliable messaging framework.

Writing to the ring buffer

Looking at the figure above, we find ourselves in the middle of the action. The ring buffer is an array of length 4 and is populated with data items - 4,5,6 and 7, which in the case of the disruptor are known as events. The square above the ring buffer containing the number 7 is the current sequence number, which denotes the highest populated event in the ring buffer. The ring buffer keeps track of this sequence number and increments it as and when new events are published to it. The fooHandler, barHandler and fooBarHandler are the consumers, which in disruptor terminology are called ‘event processors'. Each of these also has a square containing a sequence number, which in the case of the event processors denotes the highest event that they have consumed/processed so far. Thus its apparent that each entity (except the publisher) tracks its own sequence number and thus does not need to rely on a third party to figure out which is the next event its after.

The publisher asks the ring buffer for the next sequence number. The ring buffer is currently at 7, so the next sequence number would be 8. However, this would also entail overwriting the event with sequence number 4 (since there are only 4 slots in the array and the oldest event gets replaced with the newest one). The ring buffer first checks the most downstream consumer (fooBarHandler) to determine whether it is done processing the event with sequence number 4. In this case, it has, so it returns the number 8 to the publisher. In case fooBarHandler was stuck at a sequence number lower than 4, the ring buffer would have waited for it to finish processing the 4th event before returning the next sequence number to the publisher. This sequence number helps the publisher identify the next available slot in the ring buffer by performing a simple mod operation. indexOfNextAvailableSlot = highestSeqNo%longthOfRingBuffer, which in this case is 0 (8%4). The publisher then claims the next slot in the ring buffer (via a customizable strategy depending on whether there is a single or multiple publishers), which is currently occupied by event 4, and publishes event 8 to it.

Reading from the ring buffer by immediate consumers

The figure above shows the state of operations after the publisher has published event 8 to the ring buffer. The ring buffer's sequence number has been updated to 8 and now contains events 5,6,7 and 8. We see that foohandler, which has processed events upto 7, has been waiting (using a customizable strategy) for the 8th event to be published. Unlike the publisher though, it does not directly communicate with the ring buffer, but uses an entity known as the ‘sequence barrier' to do so on its behalf. The sequence barrier let's fooHandler know that the highest sequence number available in the ring buffer is now 8. FooHandler may now get this event and process it.

Similarly, barHandler checks the sequence barrier to determine whether there are any more events it can process. However, rather than just telling barHandler that the next (6th) event is up for grabs, the sequence barrier returns the highest sequence number present in the ring buffer to barHandler too. This way, barHandler can grab events 6,7,8 and process them in a batch before it has to enquire about further events being published. This saves time and reduces load.

Another important thing to note here is that in the case of multiple event processors, any given field in the event object must only be written to by any one event processor. Doing so prevents write contention, and thus removes the need for locks or CAS.

Reading from the ring buffer by downstream consumers

A few moments after the set of immediate consumers grab the next set of data, the state of affairs looks like the figure above. fooHandler is done processing all 8 available events (and has accordingly updated its sequence number to 8), whereas barHandler, being the slow coach that it is, has only processed events upto number 6 (and thus has updated sequence number to 6). We now see that fooBarHandler, which was done processing events upto number 5 at the start of our examination, is still waiting for an event higher than that to process. Why did its sequence barrier not inform it once event 8 was published to the ring buffer? Well, that is because downstream consumers don't automatically get notified of the highest sequence number present in the ring buffer. Their sequence barriers on the other hand determine the next sequence number they can process by calculating the minimum sequence number that the set of event processors directly before them have processed. This helps ensure that the downstream consumers only act on an event once its processing has been completed by the entire set of upstream consumers. The sequence barrier examines the sequence number on fooHandler (which is 8) and the sequence number on barHandler (which is 6) and decides that event 6 is the highest event that fooBarHandler can process. It returns this info to fooBarHandler, which then grabs event 6 and processes it. It must be noted that even in the case of the downstream consumers, they grab the events directly from the ring buffer and not from the consumers before them.

Well, that is about all you would need to know about the working of the disruptor framework to get started. But while this is all well and good in theory, the question still remains, how would one code the above architecture using the disruptor library? The answer to that question lies below.

Coding the disruptor

public final class FooBarEvent {
private double foo=0;
private double bar=0;
public double getFoo(){
return foo;
}
public double getBar() {
return bar;
}
public void setFoo(final double foo) {
this.foo = foo;
}
public void setBar(final double bar) {
this.bar = bar;
}
public final static EventFactory<FooBarEvent> EVENT_FACTORY
= new EventFactory<FooBarEvent>() {
public FooBarEvent newInstance() {
return new FooBarEvent();
}
};
}

The class FooBarEvent, as the name suggests, acts as the event object which is published by the publisher to the ring buffer and consumed by the eventProcessors - fooHandler, barHandler and fooBarHandler. It contains two fields ‘foo' and ‘bar' of type double, along with their corresponding setters/getters. It also contains an entity ‘EVENT_FACTORY' of type EventFactory, which is used to create an instance of this event.

public class FooBarDisruptor {           
public static final int RING_SIZE=4;
public static final ExecutorService EXECUTOR
=Executors.newCachedThreadPool();

final EventTranslator<FooBarEvent> eventTranslator
=new EventTranslator<FooBarEvent>() {
public void translateTo(FooBarEvent event,
long sequence) {
double foo=event.getFoo();
double bar=event.getBar();
system.out.println("foo="+foo
+", bar="+bar
+" (sequence="+sequence+")");
}
};

final EventHandler<FooBarEvent> fooHandler
= new EventHandler<FooBarEvent>() {
public void onEvent(final FooBarEvent event,
final long sequence,
final boolean endOfBatch)
throws Exception {
double foo=Math.random();
event.setFoo(foo);
System.out.println("setting foo to "+foo
+" (sequence="+sequence+")");
}
};

final EventHandler<FooBarEvent> barHandler
= new EventHandler<FooBarEvent>() {
public void onEvent(final FooBarEvent event,
final long sequence,
final boolean endOfBatch)
throws Exception {
double bar=Math.random();
event.setBar(bar);
System.out.println("setting bar to "+bar
+" (sequence="+sequence+")");
}
};

final EventHandler<FooBarEvent> fooBarHandler
= new EventHandler<FooBarEvent>() {
public void onEvent(final FooBarEvent event,
final long sequence,
final boolean endOfBatch)
throws Exception {
double foo=event.getFoo();
double bar=event.getBar();
System.out.println("foo="+foo
+", bar="+bar
+" (sequence="+sequence+")");
}
};

public Disruptor setup() {
Disruptor<FooBarEvent> disruptor =
new Disruptor<FooBarEvent>(FooBarEvent.EVENT_FACTORY,
EXECUTOR,
new SingleThreadedClaimStrategy(RING_SIZE),
new SleepingWaitStrategy());
disruptor.handleEventsWith(fooHandler, barHandler).then(fooBarHandler);
RingBuffer<FooBarEvent> ringBuffer = disruptor.start();             
return disruptor;
}

public void publish(Disruptor<FooBarEvent> disruptor) {
for(int i=0;i<1000;i++) {
disruptor.publishEvent(eventTranslator);
}
}

public static void main(String[] args) {
FooBarDisruptor fooBarDisruptor=new FooBarDisruptor();
Disruptor disruptor=fooBarDisruptor.setup();
fooBarDisruptor.publish(disruptor);
}
}

The class FooBarDisruptor is where all the action happens. The ‘eventTranslator' is an entity which aids the publisher in publishing events to the ring buffer. It implements a method ‘translateTo' which gets invoked when the publisher is granted permission to publish the next event. fooHandler, barHandler and fooBarHandler are the event processors, and are objects of type ‘EventHandler'. Each of them implements a method ‘onEvent' which gets invoked once the event processor is granted access to a new event. The method ‘setup' is responsible for creating the disruptor, assigning the corresponding event handlers, and setting the dependency rules amongst them. The method ‘publish' is responsible for publishing a thousand events of the type ‘FooBarEvent' to the ring buffer.

In order to get the above code to work, you must download the disruptor jar file from http://code.google.com/p/disruptor/downloads/list and include the same in your classpath.

Conclusion
The disruptor is currently in use in the ultra efficient LMAX architecture, where it has proven to be a reliable model for inter thread communication and data sharing, reducing the end to end latency to a fraction of what queue based architectures provided. It does so using a variety of techniques, including replacing the array blocking queue with a ring buffer, getting rid of all locks, write contention and CAS operations (except in the scenario where one has multiple publishers), having each entity track its own progress by way of a sequence number, etc. Adopting this framework can greatly boost a developer's productivity in terms of coding a producer-consumer pattern, while at the same time aid in creating an end product far superior in terms of both design and performance to the legacy queue based architectures.

More Stories By Sanat Vij

Sanat Vij is a professional software engineer currently working at CenturyLink. He has vast experience in developing high availability applications, configuring application servers, JVM profiling and memory management. He specializes in performance tuning of applications, reducing response times, and increasing stability.

Comments (0)

Share your thoughts on this story.

Add your comment
You must be signed in to add a comment. Sign-in | Register

In accordance with our Comment Policy, we encourage comments that are on topic, relevant and to-the-point. We will remove comments that include profanity, personal attacks, racial slurs, threats of violence, or other inappropriate material that violates our Terms and Conditions, and will block users who make repeated violations. We ask all readers to expect diversity of opinion and to treat one another with dignity and respect.


@MicroservicesExpo Stories
Join us at Cloud Expo | @ThingsExpo 2016 – June 7-9 at the Javits Center in New York City and November 1-3 at the Santa Clara Convention Center in Santa Clara, CA – and deliver your unique message in a way that is striking and unforgettable by taking advantage of SYS-CON's unmatched high-impact, result-driven event / media packages.
In the rush to compete in the digital age, a successful digital transformation is essential, but many organizations are setting themselves up for failure. There’s a common misconception that the process is just about technology, but it’s not. It’s about your business. It shouldn’t be treated as an isolated IT project; it should be driven by business needs with the committed involvement of a range of stakeholders.
SYS-CON Events announced today that BMC Software has been named "Siver Sponsor" of SYS-CON's 18th Cloud Expo, which will take place on June 7-9, 2015 at the Javits Center in New York, New York. BMC is a global leader in innovative software solutions that help businesses transform into digital enterprises for the ultimate competitive advantage. BMC Digital Enterprise Management is a set of innovative IT solutions designed to make digital business fast, seamless, and optimized from mainframe to mo...
SoftLayer operates a global cloud infrastructure platform built for Internet scale. With a global footprint of data centers and network points of presence, SoftLayer provides infrastructure as a service to leading-edge customers ranging from Web startups to global enterprises. SoftLayer's modular architecture, full-featured API, and sophisticated automation provide unparalleled performance and control. Its flexible unified platform seamlessly spans physical and virtual devices linked via a world...
18th Cloud Expo, taking place June 7-9, 2016, at the Javits Center in New York City, NY, will feature technical sessions from a rock star conference faculty and the leading industry players in the world. Cloud computing is now being embraced by a majority of enterprises of all sizes. Yesterday's debate about public vs. private has transformed into the reality of hybrid cloud: a recent survey shows that 74% of enterprises have a hybrid cloud strategy. Meanwhile, 94% of enterprises are using some...
SYS-CON Events announced today that Isomorphic Software will exhibit at SYS-CON's [email protected] at Cloud Expo New York, which will take place on June 7-9, 2016, at the Javits Center in New York City, NY. Isomorphic Software provides the SmartClient HTML5/AJAX platform, the most advanced technology for building rich, high-productivity enterprise web applications for any device. SmartClient couples the industry’s broadest, deepest UI component set with a java server framework to deliver an end-...
SYS-CON Events announced today that Tintri Inc., a leading producer of VM-aware storage (VAS) for virtualization and cloud environments, will exhibit at the 18th International CloudExpo®, which will take place on June 7-9, 2016, at the Javits Center in New York City, New York, and the 19th International Cloud Expo, which will take place on November 1–3, 2016, at the Santa Clara Convention Center in Santa Clara, CA.
You might already know them from theagileadmin.com, but let me introduce you to two of the leading minds in the Rugged DevOps movement: James Wickett and Ernest Mueller. Both James and Ernest are active leaders in the DevOps space, in addition to helping organize events such as DevOpsDays Austinand LASCON. Our conversation covered a lot of bases from the founding of Rugged DevOps to aligning organizational silos to lessons learned from W. Edwards Demings.
SYS-CON Events announced today that Commvault, a global leader in enterprise data protection and information management, has been named “Bronze Sponsor” of SYS-CON's 18th International Cloud Expo, which will take place on June 7–9, 2016, at the Javits Center in New York City, NY, and the 19th International Cloud Expo, which will take place on November 1–3, 2016, at the Santa Clara Convention Center in Santa Clara, CA. Commvault is a leading provider of data protection and information management...
As AT&Ts VP of Domain 2.0 architecture writes one aspect of their Domain 2.0 strategy is a goal to embrace a Microservices Application Architecture. One page 9 they describe how these envisage them fitting into the ECOMP architecture: "The initial steps of the recipes include a homing and placement task using constraints specified in the requests. ‘Homing and Placement' are micro-services involving orchestration, inventory, and controllers responsible for infrastructure, network, and applicati...
Many banks and financial institutions are experimenting with containers in development environments, but when will they move into production? Containers are seen as the key to achieving the ultimate in information technology flexibility and agility. Containers work on both public and private clouds, and make it easy to build and deploy applications. The challenge for regulated industries is the cost and complexity of container security compliance. VM security compliance is already challenging, ...
Application development and delivery methods have undergone radical changes in recent years to improve scalability and resiliency. Container images are the new build and deployment artifacts that are used to ship and run software. While startups have long been comfortable experimenting with and embracing new technologies, even large enterprises are now re-architecting their software systems so that they can benefit from container-enabled micro services architectures. With the launch of DC/OS, w...
SYS-CON Events announced today that Alert Logic, Inc., the leading provider of Security-as-a-Service solutions for the cloud, will exhibit at SYS-CON's 18th International Cloud Expo®, which will take place on June 7-9, 2016, at the Javits Center in New York City, NY. Alert Logic, Inc., provides Security-as-a-Service for on-premises, cloud, and hybrid infrastructures, delivering deep security insight and continuous protection for customers at a lower cost than traditional security solutions. Ful...
When I talk about driving innovation with self-organizing teams, I emphasize that such self-organization includes expecting the participants to organize their own teams, give themselves their own goals, and determine for themselves how to measure their success. In contrast, the definition of skunkworks points out that members of such teams are “usually specially selected.” Good thing he added the word usually – because specially selecting such teams throws a wrench in the entire works, limiting...
Earlier this week, we hosted a Continuous Discussion (#c9d9) on Continuous Delivery (CD) automation and orchestration, featuring expert panelists Dondee Tan, Test Architect at Alaska Air, Taco Bakker, a LEAN Six Sigma black belt focusing on CD, and our own Sam Fell and Anders Wallgren. During this episode, we discussed the differences between CD automation and orchestration, their challenges with setting up CD pipelines and some of the common chokepoints, as well as some best practices and tips...
SYS-CON Events announced today that EastBanc Technologies will exhibit at SYS-CON's 18th International Cloud Expo®, which will take place on June 7-9, 2016, at the Javits Center in New York City, NY. EastBanc Technologies has been working at the frontier of technology since 1999. Today, the firm provides full-lifecycle software development delivering flexible technology solutions that seamlessly integrate with existing systems – whether on premise or cloud. EastBanc Technologies partners with p...
SYS-CON Events announced today TechTarget has been named “Media Sponsor” of SYS-CON's 18th International Cloud Expo, which will take place on June 7–9, 2016, at the Javits Center in New York City, NY, and the 19th International Cloud Expo, which will take place on November 1–3, 2016, at the Santa Clara Convention Center in Santa Clara, CA. TechTarget is the Web’s leading destination for serious technology buyers researching and making enterprise technology decisions. Its extensive global networ...
Automation is a critical component of DevOps and Continuous Delivery. This morning on #c9d9 we discussed CD Automation and how you can apply Automation to accelerate release cycles, improve quality, safety and governance? What is the difference between Automation and Orchestration? Where should you begin your journey to introduce both?
SYS-CON Events announced today BZ Media LLC has been named “Media Sponsor” of SYS-CON's 19th International Cloud Expo, which will take place on November 1–3, 2016, at the Santa Clara Convention Center in Santa Clara, CA. BZ Media LLC is a high-tech media company that produces technical conferences and expositions, and publishes a magazine, newsletters and websites in the software development, SharePoint, mobile development and Commercial Drone markets.
A strange thing is happening along the way to the Internet of Things, namely far too many devices to work with and manage. It has become clear that we'll need much higher efficiency user experiences that can allow us to more easily and scalably work with the thousands of devices that will soon be in each of our lives. Enter the conversational interface revolution, combining bots we can literally talk with, gesture to, and even direct with our thoughts, with embedded artificial intelligence, wh...