disruptor

Strange to see a lock-free ring buffer without seeing mention of LMAX/Martin Thompson's Java Disruptor (https://github.com/LMAX-Exchange/disruptor)

I still use it. They finally fixed my biggest complaint about it a year ago, which is that you couldn't use vanilla Clojure lambdas for the Java functional interface, and so you'd have to reify that interface and it was bulky and ugly. Now it works fine so long as the interfaces actually have the @FunctionalInterface attribute. Not every project uses @FunctionalInterface, but I've been trying to add it to places [1] [2] [3], and now I'm able to use Clojure in a lot more places. [1] https://github.com/LMAX-Exchange/disruptor/pull/492 [2] https://github.com/apache/kafka/pull/19234 [3] https://github.com/apache/kafka/pull/19366

there's also the Disruptor https://github.com/LMAX-Exchange/disruptor

LMAX have an open source version of the disruptor in GitHub https://github.com/LMAX-Exchange/disruptor

I played around with the original (Java) LMAX disruptor which was an interesting and different way to achieve latency/throughput. Didn't find a whitepaper--here's some references[0] which includes a Martin Fowler post[1]. [0] https://github.com/LMAX-Exchange/disruptor/wiki/Blogs-And-Ar... [1] https://martinfowler.com/articles/lmax.html

See also the Java LMAX Disruptor https://github.com/LMAX-Exchange/disruptor I've built a similar lock-free ring buffer in C++11 https://github.com/posterior/loom/blob/master/doc/adapting.m...

LMAX Disruptor has on their wiki that average latency to send a message from one thread to another at 53 nanoseconds. For comparison a mutex is like 25 nanoseconds and more if Contended but a mutex is point to point synchronization. The great thing about the disruptor it is that multiple threads can receive the same message without much more effort. https://github.com/LMAX-Exchange/disruptor/wiki/Performance-... https://gist.github.com/rmacy/2879257 I am dreaming of language that is similar to Smalltalk that stays single threaded until it makes sense to parallise. I am looking for problems for parallelism that are not big data. Parallelism is like adding more cars to the road rather than increasing the speed of the car. But what does a desktop or mobile user need to do locally that could take advantage of the mathematical power of a compu

Thanks. It's a pattern I saw in https://github.com/LMAX-Exchange/disruptor.

Nothing taught me as much about API design and testing as Google's Guava. I know there are lots of minor gripes with that library, but is it so incredibly consistent. It is also amazing that no one mentioned the Java Collections (ArrayList, LinkedList, HashSet, HashMap, TreeSet, TreeMap). They are some of the highest quality generic collections that exist anywhere. (For C++, I would say the same about an STL implementation by a high quality project like VCC/GCC/Clang.) For "Java high honors", try to understand how concurrent collections work, e.g., ConcurrentHashMap! For highly specialised containers, try: (1) https://labs.carrotsearch.com/hppc.html, (2) https://github.com/OpenHFT/Chronicle-Queue, and (3) https://github.com/LMAX-Exchange/disruptor

log4j2 AsyncLogger uses RingBuffer (Disruptor) which is lock-free https://github.com/LMAX-Exchange/disruptor/wiki/Blogs-And-Ar...

in LMAX-disruptor's case, they have no runtime dependencies: https://github.com/LMAX-Exchange/disruptor/blob/master/build...

If anyone is curious, one of the fastest multi-threaded queue implementations out there is the LMAX Disruptor. https://github.com/LMAX-Exchange/disruptor https://github.com/LMAX-Exchange/disruptor/wiki/Performance-... I've started using a variant of this in my .NET Core projects and have found the performance to be astonishing.

There is an open-source project by LMAX (a forex trading company) called Disruptor[1] that squeezes as much as possible out of the JVM. It's awesome. I ported it to C++ years ago when I wanted to learn about low-latency techniques. However, if you look at the code they need to actually break out of the JVM's safety net to get the performance they need[2]. I couldn't help but ask myself why they didn't just use C++, and when asked one of the devs did admit that their own C++ ports had an approx 10% performance increase (although this was ~7 years ago maybe) Rust is certainly interesting and it's on my radar. I wonder though, when it comes to having it in use in anger if its guarantees turn out to be over sold, just like the JVM's safety claims were. Time will tell. Edit: I tend to focus on comapring against the JVM because pretty much any