Concurrent Ruby

Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell, F#, C#, Java, and classic concurrency patterns.

The design goals of this gem are:

Be an 'unopinionated' toolbox that provides useful utilities without debating which is better or why
Remain free of external gem dependencies
Stay true to the spirit of the languages providing inspiration
But implement in a way that makes sense for Ruby
Keep the semantics as idiomatic Ruby as possible
Support features that make sense in Ruby
Exclude features that don't make sense in Ruby
Be small, lean, and loosely coupled

Supported Ruby versions

MRI 1.9.3, 2.0, 2.1, 2.2, JRuby (1.9 mode), and Rubinius 2.x are supported. This gem should be fully compatible with any interpreter that is compliant with Ruby 1.9.3 or newer.

Features & Documentation

We have a roadmap guiding our work toward the v1.0.0 release.

The primary site for documentation is the automatically generated API documentation

We also have a mailing list.

This library contains a variety of concurrency abstractions at high and low levels. One of the high-level abstractions is likely to meet most common needs.

High-level, general-purpose asynchronous concurrency abstractions

Actor: Implements the Actor Model, where concurrent actors exchange messages.
Agent: A single atomic value that represents an identity.
Async: A mixin module that provides simple asynchronous behavior to any standard class/object or object.
Future: An asynchronous operation that produces a value.
- Dataflow: Built on Futures, Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
Promise: Similar to Futures, with more features.
ScheduledTask: Like a Future scheduled for a specific future time.
TimerTask: A Thread that periodically wakes up to perform work at regular intervals.
Channel: Communicating Sequential Processes (CSP).

Java-inspired ThreadPools and other executors

See ThreadPool overview, which also contains a list of other Executors available.

Thread-safe Observers

Thread synchronization classes and algorithms

Lower-level abstractions mainly used as building blocks.

Thread-safe variables

Lower-level abstractions mainly used as building blocks.

AtomicBoolean
AtomicFixnum
AtomicReference (no docs currently available, check source)
I-Structures (IVar)
M-Structures (MVar)
thread-local variables
software transactional memory (TVar)

Usage

All abstractions within this gem can be loaded simply by requiring it:

require 'concurrent'

To reduce the amount of code loaded at runtime, subsets of this gem can be required:

require 'concurrent'                # everything

# groups

require 'concurrent/actor'          # Concurrent::Actor and supporting code
require 'concurrent/atomics'        # atomic and thread synchronization classes
require 'concurrent/channels'       # Concurrent::Channel and supporting code
require 'concurrent/executors'      # Thread pools and other executors
require 'concurrent/utilities'      # utility methods such as processor count and timers

# individual abstractions

require 'concurrent/agent'          # Concurrent::Agent
require 'concurrent/async'          # Concurrent::Async
require 'concurrent/atomic'         # Concurrent::Atomic (formerly the `atomic` gem)
require 'concurrent/dataflow'       # Concurrent::dataflow
require 'concurrent/delay'          # Concurrent::Delay
require 'concurrent/exchanger'      # Concurrent::Exchanger
require 'concurrent/future'         # Concurrent::Future
require 'concurrent/ivar'           # Concurrent::IVar
require 'concurrent/mvar'           # Concurrent::MVar
require 'concurrent/promise'        # Concurrent::Promise
require 'concurrent/scheduled_task' # Concurrent::ScheduledTask
require 'concurrent/timer_task'     # Concurrent::TimerTask
require 'concurrent/tvar'           # Concurrent::TVar

Installation

gem install concurrent-ruby

or add the following line to Gemfile:

gem 'concurrent-ruby'

and run bundle install from your shell.

C Extensions for MRI

Potential performance improvements may be achieved under MRI by installing optional C extensions. To minimize installation errors the C extensions are available in the concurrent-ruby-ext extension gem. The extension gem lists concurrent-ruby as a dependency so it is not necessary to install both. Simply install the extension gen:

gem install concurrent-ruby-ext

or add the following line to Gemfile:

gem 'concurrent-ruby-ext'

and run bundle install from your shell.

In code it is only necessary to

require 'concurrent'

The concurrent-ruby gem will automatically detect the presence of the concurrent-ruby-ext gem and load the appropriate C extensions.

Note For gem developers

No gems should depend on concurrent-ruby-ext. Doing so will force C extensions on your users. The best practice is to depend on concurrent-ruby and let users to decide if they want C extensions.

Building

All published versions of this gem (core, extension, and several platform-specific packages) are compiled, packaged, tested, and published using an open, automated process. This process can also be used to create pre-compiled binaries of the extension gem for virtally any platform. Documentation is forthcoming...

*MRI only*
rake build:native       # Build concurrent-ruby-ext-<version>-<platform>.gem into the pkg directory
rake compile:extension  # Compile extension

*JRuby only*
rake build              # Build JRuby-specific core gem (alias for `build:core`)
rake build:core         # Build concurrent-ruby-<version>-java.gem into the pkg directory

*All except JRuby*
rake build              # Build core and extension gems
rake build:core         # Build concurrent-ruby-<version>.gem into the pkg directory
rake build:ext          # Build concurrent-ruby-ext-<version>.gem into the pkg directory

*All*
rake clean              # Remove any temporary products
rake clobber            # Remove any generated file
rake compile            # Compile all the extensions

Maintainers

Contributing

Fork it
Create your feature branch (git checkout -b my-new-feature)
Commit your changes (git commit -am 'Add some feature')
Push to the branch (git push origin my-new-feature)
Create new Pull Request

License and Copyright

Concurrent Ruby is free software released under the MIT License.