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
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.