|
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:
|
|
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.
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.
- 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.
- See ThreadPool overview, which also contains a list of other Executors available.
- AtomicBoolean
- AtomicFixnum
- AtomicReference
- Delay
- LazyRegister
- I-Structures (IVar)
- M-Structures (MVar)
- Thread-local variables
- Software transactional memory (TVar)
- ReadWriteLock
They are available in the concurrent-ruby-edge companion gem, install with gem install concurrent-ruby-edge.
These features are under active development and may change frequently. They are expected not to
keep backward compatibility (there may also lack tests and documentation). Semantic versions will
be obeyed though. Features developed in concurrent-ruby-edge are expected to move to concurrent-ruby when final.
- Actor: Implements the Actor Model, where concurrent actors exchange messages.
- Channel: Communicating Sequential Processes (CSP).
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/atomics' # atomic and thread synchronization classes
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/lazy_register' # Concurrent::LazyRegister
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
# experimental - available in `concurrent-ruby-edge` companion gem
require 'concurrent/actor' # Concurrent::Actor and supporting code
require 'concurrent/channel ' # Concurrent::Channel and supporting codegem install concurrent-rubyor add the following line to Gemfile:
gem 'concurrent-ruby'and run bundle install from your shell.
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. concurrent-ruby and concurrent-ruby-ext are always released together with same version.
Simply install the extension gen too:
gem install concurrent-ruby-extor 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.
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.
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*
bundle exec rake build:native # Build concurrent-ruby-ext-<version>-<platform>.gem into the pkg dir
bundle exec rake compile:extension # Compile extension
*JRuby only*
bundle exec rake build # Build JRuby-specific core gem (alias for `build:core`)
bundle exec rake build:core # Build concurrent-ruby-<version>-java.gem into the pkg directory
*All except JRuby*
bundle exec rake build # Build core and extension gems
bundle exec rake build:core # Build concurrent-ruby-<version>.gem into the pkg directory
bundle exec rake build:ext # Build concurrent-ruby-ext-<version>.gem into the pkg directory
*All*
bundle exec rake clean # Remove any temporary products
bundle exec rake clobber # Remove any generated file
bundle exec rake compile # Compile all the extensions
- 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
Concurrent Ruby is free software released under the MIT License.
The Concurrent Ruby logo was designed by David Jones. It is Copyright © 2014 Jerry D'Antonio. All Rights Reserved.