This post is an overview of the concurrency features of Java 7. This includes the Fork/Join Framework, the TransferQueue and the ThreadLocalRandom class
MINA is a simple yet full-featured network application framework which provides:
* Unified API for various transport types:
o TCP/IP & UDP/IP via Java NIO
o Serial communication (RS232) via RXTX
o In-VM pipe communication
o You can implement your own!
* Filter interface as an extension point; similar to Servlet filters
* Low-level and high-level API:
o Low-level: uses ByteBuffers
o High-level: uses user-defined message objects and codecs
* Highly customizable thread model:
o Single thread
o One thread pool
o More than one thread pools (i.e. SEDA)
* Out-of-the-box SSL · TLS · StartTLS support using Java 5 SSLEngine
* Overload shielding & traffic throttling
* Unit testability using mock objects
* JMX managability
* Stream-based I/O support via StreamIoHandler
* Integration with well known containers such as PicoContainer and Spring
* Smooth migration from Netty, an ancestor of Apache MINA.
JPPF enables applications with large processing power requirements to be run on any number of computers, in order to dramatically reduce their processing time. This is done by splitting an application into smaller parts that can be executed simultaneously on different machines.
Jetlang provides a high performance java threading library. The library is based upon Retlang.
The library is a complement to the java.util.concurrent package introduced in 1.5 and should be used for message based concurrency similar to event based actors in Scala.
The library does not provide remote messaging capabilities. It is designed specifically for high performance in-memory messaging.
Features¶
* All messages to a particular Fiber are delivered sequentially. Components can easily keep state without synchronizing data access or worrying about thread races.
* Single Fiber interface that can be backed by a dedicated thread or a thread pool.
* Supports single or multiple subscribers for messages.
* Subscriptions for single events or event batching
* Single or recurring event scheduling
* High performance design optimized for low latency and high scalability
* Publishing is thread safe, allowing easy integration with other threading models.
* Low Lock Contention - Minimizing lock contention is critical for performance. Other concurrency solutions are limited by a single lock typically on a central thread pool or message queue. Jetlang is optimized for low lock contention. Without a central bottleneck, performance easily scales to the needs of the application.
* Powerful Async Request/Reply Support
* Single jar with no dependencies except the jdk (1.6+)
* Integrates with any JVM language - jruby, scala, clojure, groovy, etc
Akka is the platform for the next generation event-driven, scalable and fault-tolerant architectures on the JVM
We believe that writing correct concurrent, fault-tolerant and scalable applications is too hard. Most of the time it's because we are using the wrong tools and the wrong level of abstraction.
Akka is here to change that.
Using the Actor Model together with Software Transactional Memory we raise the abstraction level and provides a better platform to build correct concurrent and scalable applications.
For fault-tolerance we adopt the "Let it crash" / "Embrace failure" model which have been used with great success in the telecom industry to build applications that self-heals, systems that never stop.
Actors also provides the abstraction for transparent distribution and the basis for truly scalable and fault-tolerant applications.
Akka is Open Source and available under the Apache 2 License.
Parallel4 is a easy-to-use multi-threading API for Java an other JVM based languages like Groovy. It offers parallel versions of the "for" and "foreach" loops to leverage the full power of todays multi-core CPUs.
Parallel4's goals are:
* Simple API: Hide as many details of multi-threaded programming as possible from the API. Although it does not offer transparent/implicit multi-threading in a strict sense, it tries to come as close to this as a non-functional programming language allows.
* Familiar API: Offer well known constructs, e.g. the "for" loop and add parallelism to it.
* Easy adaptation of parallel programming: Based on a familiar API, it is easy to introduce multi-threading. Often, two additional lines of code are enough without imposing any structural changes.
* Adaptive: Let the "framework" make reasonable defaults to adapt to the execution environment, e.g. use as many threads as CPU cores are available.
* Performance: A low overhead makes it easy to decide whether to use parallel processing or not.
* Reliable: Multi-threading gets tricky when things go wrong unexpectedly. A well defined exception handling makes this a bit easier.
Kilim is a message-passing framwork for Java that provides ultra-lightweight threads and facilities for fast, safe, zero-copy messaging between these threads.
A collection of Concurrent and Highly Scalable Utilities. These are intended as direct replacements for the java.util.* or java.util.concurrent.* collections but with better performance when many CPUs are using the collection concurrently.
This package is the backport of java.util.concurrent API, introduced in Java 5.0 and further refined in Java 6.0, to older Java platforms. The backport is based on public-domain sources from the JSR 166 CVS repository, the dl.util.concurrent package, and
I participated in the design and development of a couple of concurrency libraries for shared-memory multiprocessors long before such machines were popular. So when I started using java.util.concurrent I was already somewhat comfortable with the concepts.
The Java™ programming language made starting a new thread easier than ever before. But freeing your concurrent programs of obscure bugs is a different matter, and Java's programming model might not be the best available. A language called Erlang is getting some good press now in the areas of concurrency, distributed systems, and soft real-time systems.
J. Roemer, K. Genc, and M. Bond. Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation, page 374--389. ACM, (2018)
Y. Hayduk, A. Sobe, and P. Felber. Distributed Applications and Interoperable Systems, volume 9038 of Lecture Notes in Computer Science, Springer, (2015)
B. Claudel, Q. Sabah, and J. Stefani. Formal Techniques for Distributed Objects, Components, and Systems, volume 9039 of Lecture Notes in Computer Science, Springer, (2015)
B. Demsky, and P. Lam. Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering - Volume 1, page 395--404. New York, NY, USA, ACM, (2010)
T. Cutsem, S. Mostinckx, and W. Meuter. Computer Languages, Systems & Structures, 35 (1):
80 - 98(2009)ESUG 2007 International Conference on Dynamic Languages (ESUG/ICDL 2007).
H. Schippers, T. Van Cutsem, S. Marr, M. Haupt, and R. Hirschfeld. Proceedings of the Fourth Workshop on the Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS), page 4--9. ACM, (Jul 6, 2009)
R. Kaiabachev, and B. Richards. Proc. of Fifteenth IASTED International Conference on Parallel and Distributed Computing and Systems, page 648-653. Marina del Ray, CA, USA, (November 2003)