Welcome!

Microservices Expo Authors: Liz McMillan, Pat Romanski, Elizabeth White, Stackify Blog, Yeshim Deniz

Related Topics: Java IoT, Industrial IoT, Microservices Expo, Eclipse, Machine Learning , 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
SYS-CON Events announced today that Fusion, a leading provider of cloud services, will exhibit at SYS-CON's 20th International Cloud Expo®, which will take place on June 6-8, 2017, at the Javits Center in New York City, NY. Fusion, a leading provider of integrated cloud solutions to small, medium and large businesses, is the industry’s single source for the cloud. Fusion’s advanced, proprietary cloud service platform enables the integration of leading edge solutions in the cloud, including cloud...
SYS-CON Events announced today that Peak 10, Inc., a national IT infrastructure and cloud services provider, will exhibit at SYS-CON's 20th International Cloud Expo®, which will take place on June 6-8, 2017, at the Javits Center in New York City, NY. Peak 10 provides reliable, tailored data center and network services, cloud and managed services. Its solutions are designed to scale and adapt to customers’ changing business needs, enabling them to lower costs, improve performance and focus intern...
DevOps at Cloud Expo – being held October 31 - November 2, 2017, at the Santa Clara Convention Center in Santa Clara, CA – announces that its Call for Papers is open. Born out of proven success in agile development, cloud computing, and process automation, DevOps is a macro trend you cannot afford to miss. From showcase success stories from early adopters and web-scale businesses, DevOps is expanding to organizations of all sizes, including the world's largest enterprises – and delivering real r...
SYS-CON Events announced today that CollabNet, a global leader in enterprise software development, release automation and DevOps solutions, will be a Bronze Sponsor of SYS-CON's 20th International Cloud Expo®, taking place from June 6-8, 2017, at the Javits Center in New York City, NY. CollabNet offers a broad range of solutions with the mission of helping modern organizations deliver quality software at speed. The company’s latest innovation, the DevOps Lifecycle Manager (DLM), supports Value S...
There are two main reasons for infrastructure automation. First, system administrators, IT professionals and DevOps engineers need to automate as many routine tasks as possible. That’s why we build tools at Stackify to help developers automate processes like application performance management, error monitoring, and log management; automation means you have more time for mission-critical tasks. Second, automation makes the management of complex, diverse environments possible and allows rapid scal...
SYS-CON Events announced today that HTBase will exhibit at SYS-CON's 20th International Cloud Expo®, which will take place on June 6-8, 2017, at the Javits Center in New York City, NY. HTBase (Gartner 2016 Cool Vendor) delivers a Composable IT infrastructure solution architected for agility and increased efficiency. It turns compute, storage, and fabric into fluid pools of resources that are easily composed and re-composed to meet each application’s needs. With HTBase, companies can quickly prov...
This talk centers around how to automate best practices in a multi-/hybrid-cloud world based on our work with customers like GE, Discovery Communications and Fannie Mae. Today’s enterprises are reaping the benefits of cloud computing, but also discovering many risks and challenges. In the age of DevOps and the decentralization of IT, it’s easy to over-provision resources, forget that instances are running, or unintentionally expose vulnerabilities.
SYS-CON Events announced today that Linux Academy, the foremost online Linux and cloud training platform and community, will exhibit at SYS-CON's 20th International Cloud Expo®, which will take place on June 6-8, 2017, at the Javits Center in New York City, NY. Linux Academy was founded on the belief that providing high-quality, in-depth training should be available at an affordable price. Industry leaders in quality training, provided services, and student certification passes, its goal is to c...
One of the biggest challenges with adopting a DevOps mentality is: new applications are easily adapted to cloud-native, microservice-based, or containerized architectures - they can be built for them - but old applications need complex refactoring. On the other hand, these new technologies can require relearning or adapting new, oftentimes more complex, methodologies and tools to be ready for production. In his general session at @DevOpsSummit at 20th Cloud Expo, Chris Brown, Solutions Marketi...
It has never been a better time to be a developer! Thanks to cloud computing, deploying our applications is much easier than it used to be. How we deploy our apps continues to evolve thanks to cloud hosting, Platform-as-a-Service (PaaS), and now Function-as-a-Service. FaaS is the concept of serverless computing via serverless architectures. Software developers can leverage this to deploy an individual "function", action, or piece of business logic. They are expected to start within milliseconds...
We all know that end users experience the internet primarily with mobile devices. From an app development perspective, we know that successfully responding to the needs of mobile customers depends on rapid DevOps – failing fast, in short, until the right solution evolves in your customers' relationship to your business. Whether you’re decomposing an SOA monolith, or developing a new application cloud natively, it’s not a question of using microservices - not doing so will be a path to eventual ...
@DevOpsSummit at Cloud taking place June 6-8, 2017, at Javits Center, New York City, is co-located with the 20th International Cloud Expo and will feature technical sessions from a rock star conference faculty and the leading industry players in the world. The widespread success of cloud computing is driving the DevOps revolution in enterprise IT. Now as never before, development teams must communicate and collaborate in a dynamic, 24/7/365 environment. There is no time to wait for long developm...
With 10 simultaneous tracks, keynotes, general sessions and targeted breakout classes, Cloud Expo and @ThingsExpo are two of the most important technology events of the year. Since its launch over eight years ago, Cloud Expo and @ThingsExpo have presented a rock star faculty as well as showcased hundreds of sponsors and exhibitors! In this blog post, I provide 7 tips on how, as part of our world-class faculty, you can deliver one of the most popular sessions at our events. But before reading the...
The purpose of this article is draw attention to key SaaS services that are commonly overlooked during contact signing that are essential to ensuring they meet the expectations and requirements of the organization and provide guidance and recommendations for process and controls necessary for achieving quality SaaS contractual agreements.
SYS-CON Events announced today that OpsGenie will exhibit at SYS-CON's 20th International Cloud Expo®, which will take place on June 6-8, 2017, at the Javits Center in New York City, NY. Founded in 2012, OpsGenie is an alerting and on-call management solution for dev and ops teams. OpsGenie provides the tools needed to design actionable alerts, manage on-call schedules and escalations, and ensure that the right people are notified at the right time, using multiple notification methods.
The first step to solving a problem is recognizing that it actually exists. And whether you've realized it or not, cloud services are a problem for your IT department. Even if you feel like you have a solid grasp of cloud technology and the nuances of making a cloud purchase, business leaders don't share the same confidence. Nearly 80% feel that IT lacks the skills necessary to help with cloud purchases-and they're looking to cloud brokers for help instead. It's time to admit we have a cloud s...
According to a recent Gartner study, by 2020, it will be unlikelythat any enterprise will have a “no cloud” policy, and hybrid will be the most common use of the cloud. While the benefits of leveraging public cloud infrastructures are well understood, the desire to keep critical workloads and data on-premise in the private data center still remains. For enterprises, the hybrid cloud provides a best of both worlds solution. However, the leading factor that determines the preference to the hybrid ...
In this modern world of IT, you've probably got some new colleagues in your life-namely, the cloud and SaaS providers who now hold your infrastructure in their hands. These business relationships-yes, they're technology-based, but cloud and SaaS are business models-will become as important to your IT team and your company as the hardware and software you used to install. Once you've adopted SaaS, or inherited SaaS, it's on you to avoid price hikes, licensing issues and app or provider sprawl....
A completely new computing platform is on the horizon. They’re called Microservers by some, ARM Servers by others, and sometimes even ARM-based Servers. No matter what you call them, Microservers will have a huge impact on the data center and on server computing in general. Although few people are familiar with Microservers today, their impact will be felt very soon. This is a new category of computing platform that is available today and is predicted to have triple-digit growth rates for some ...
In IT, we sometimes coin terms for things before we know exactly what they are and how they’ll be used. The resulting terms may capture a common set of aspirations and goals – as “cloud” did broadly for on-demand, self-service, and flexible computing. But such a term can also lump together diverse and even competing practices, technologies, and priorities to the point where important distinctions are glossed over and lost.