/disruptor

High Performance Inter-Thread Messaging Library

Primary LanguageJavaApache License 2.0Apache-2.0

LMAX Disruptor

A High Performance Inter-Thread Messaging Library

Maintainer

Michael Barker mikeb01@gmail.com

Changelog

2.10.3 Released (22-Aug-2012)

  • Bug fix, race condition in SequenceGroup when removing Sequences and getting current value

2.10.2 Released (21-Aug-2012)

  • Bug fix, potential race condition in BlockingWaitStrategy.
  • Bug fix set initial SequenceGroup value to -1 (Issue #27).
  • Deprecate timeout methods that will be removed in version 3.

2.10.1 (6-June-2012)

  • Bug fix, correct OSGI metadata.
  • Remove unnecessary code in wait strategies.

2.10 (13-May-2012)

  • Remove deprecated timeout methods.
  • Added OSGI metadata to jar file.
  • Removed PaddedAtomicLong and use Sequence in all places.
  • Fix various generics warnings.
  • Change Sequence implementation to work around IBM JDK bug and improve performance by ~10%.
  • Add a remainingCapacity() call to the Sequencer class.

2.9 (8-Apr-2012)

  • Deprecate timeout methods for publishing.
  • Add tryNext and tryPublishEvent for events that shouldn't block during delivery.
  • Small performance enhancement for MultithreadClaimStrategy.

2.8 (6-Feb-2012)

  • Create new MultithreadClaimStrategy that works between when threads are highly contended. Previous implementation is now called MultithreadLowContentionClaimStrategy
  • Fix for bug where EventProcessors weren't being added as gating sequences to the ring buffer.
  • Fix range tracking bug in Histogram

2.7.1 (21-Dec-2011)

  • Artefacts made available via maven central repository. (groupId:com.googlecode.disruptor, artifactId:disruptor) See UsingDisruptorInYourProject for details.

2.7 (12-Nov-2011)

  • Changed construction API to allow user supplied claim and wait strategies
  • Added AggregateEventHandler to support multiple EventHandlers from a single BatchEventProcessor
  • Support exception handling from LifecycleAware
  • Added timeout API calls for claiming a sequence when publishing
  • Use LockSupport.parkNanos() instead of Thread.sleep() to reduce latency
  • Reworked performance tests to better support profiling and use LinkedBlockingQueue for comparison because it performs better on the latest processors
  • Minor bugfixes

2.6

  • Introduced WorkerPool to allow the one time consumption of events by a worker in a pool of EventProcessors.
  • New internal implementation of SequenceGroup which is lock free at all times and garbage free for get and set operations.
  • SequenceBarrier now checks alert status on every call whether it is blocking or not.
  • Added scripts in preparation for publishing binaries to maven repository.

2.5.1

  • Bugfix for supporting SequenceReportingEventHandler from DSL. (issue 9)
  • Bugfix for multi-threaded publishing to multiple ring buffers (issue 10)
  • Change SequenceBarrier to always check alert status before entering waitFor cycle. Previously this was only checked when the requested sequence was not available.
  • Change ClaimStrategy to not spin when the buffer has no available capacity, instead go straight to yielding to allow event processors to catch up.

2.5

  • Changed RingBuffer and publisher API so any mutable object can be placed in the RingBuffer without having to extend AbstractEvent
  • Added EventPublisher implementation to allow the publishing steps to be combined into one action
  • DisruptorWizard has been renamed to Disruptor with added support for any subtype of EventProcessor
  • Introduced a new Sequencer class that allows the Disruptor to be applied to other data structures such as multiple arrays. This can be a very useful pattern when multiple event processors work on the same event and you want to avoid false sharing. The Diamond for FizzBuzz is a good example of the issue. It is also higher performance by avoiding the pointer indirection when arrays of primitives are used.
  • Further increased performance and scalability by reducing false sharing.
  • Added progressive backoff strategy to the MultiThreadedClaimStrategy to prevent publisher getting into the claim cycle when the buffer is full because of a slow EventProcessor.
  • Significantly improved performance to WaitStrategy.Option.BLOCKING
  • Introduced SequenceGroup to allow dynamic registration of EventProcessors.

2.0.2

  • Rework of "False Sharing" prevention which makes the performance much more predictable across all platforms. Special thanks to Jeff Hain for helping focus in on a solution.

2.0.1

  • Renaming mistake for publishEventAtSequence should have been claimEventAtSequence
  • Fixed bug in YieldingStrategy that was busy spinning more than yielding and introduced SleepingStrategy
  • Removed code duplication in Unicast perf tests for expected result

2.0.0

  • New API to reflect naming changes
  • Producer -> Publisher
  • Entry -> Event
  • Consumer -> EventProcessor
  • ConsumerBarrier -> DependencyBarrier
  • ProducerBarrier has been incorporated into the RingBuffer for ease of use
  • DisruptorWizard integrated for fluent API dependency graph construction
  • Rework of sequence tracking to avoid false sharing on Java 7, plus avoid mega-morphic calls to make better use of the instruction cache
  • Reduced usage of memory barriers where possible
  • WaitStrategy.YIELDING initially spins for a short period to reduce latency
  • Major performance improvement giving more than a 2X increase for throughput across most use cases.

1.2.2

  • ProducerBarrier change to yield after busy spinning for a while. This may help the situation when the the number of producers exceeds the number of cores.

1.2.1

  • Bug fix for setting the sequence in the ForceFillProducerBarrier.
  • Code syntax tidy up.

1.2.0

  • Bug fix for regression introduced inlining multi-thread producer commit tracking code. This was a critical bug for the multi-threaded producer scenario.
  • Added new ProducerBarrier method for claiming a batch of sequences. This feature can give a significant throughput increase.

1.1.0

  • Off by one regression bug in ProducerBarrier introduced in 1.0.9.
  • Clarified the algorithm for initial cursor value in the ClaimStrategy.

1.0.9

  • Added Apache 2.0 licence and comments.
  • Small performance improvements to producers barriers and BatchConsumer.

1.0.8

  • Bugfix for BatchConsumer sequence update when using SequenceTrackingHandler to ensure sequence is always updated at the end of a batch regardless.

1.0.7

  • Factored out LifecycleAware interface to allowing consumers handlers to be notified when their thread starts and shuts down.

1.0.6

  • Cache minimum consumer sequence in producer barriers. This helps make the performance more predictable on Nehalem processors and greater on earlier Core 2 processors.

1.0.5

  • Removed Entry interface. All Entries must now extend AbstractEntry.
  • Made setSequence package private on AbstractEntry for encapsulation.