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
- Thread-safety
- Backward compatibility
This gem depends on
contributions and we
appreciate your help. Would you like to contribute? Great! Have a look at
issues with looking-for-contributor
label. And if you pick something up let us know on the issue.
You can also get started by triaging issues which may include reproducing bug reports or asking for vital information, such as version numbers or reproduction instructions. If you would like to start triaging issues, one easy way to get started is to subscribe to concurrent-ruby on CodeTriage.
Concurrent Ruby makes one of the strongest thread safety guarantees of any Ruby concurrency library, providing consistent behavior and guarantees on all four of the main Ruby interpreters (MRI/CRuby, JRuby, Rubinius, TruffleRuby).
Every abstraction in this library is thread safe. Specific thread safety guarantees are documented with each abstraction.
It is critical to remember, however, that Ruby is a language of mutable references. No concurrency library for Ruby can ever prevent the user from making thread safety mistakes (such as sharing a mutable object between threads and modifying it on both threads) or from creating deadlocks through incorrect use of locks. All the library can do is provide safe abstractions which encourage safe practices. Concurrent Ruby provides more safe concurrency abstractions than any other Ruby library, many of which support the mantra of "Do not communicate by sharing memory; instead, share memory by communicating". Concurrent Ruby is also the only Ruby library which provides a full suite of thread safe and immutable variable types and data structures.
We've also initiated discussion to document memory model of Ruby which would provide consistent behaviour and guarantees on all four of the main Ruby interpreters (MRI/CRuby, JRuby, Rubinius, TruffleRuby).
The primary site for documentation is the automatically generated API documentation which is up to date with latest release. This readme matches the master so may contain new stuff not yet released.
We also have a IRC (gitter).
concurrent-ruby
uses Semantic Versioningconcurrent-ruby-ext
has always same version asconcurrent-ruby
concurrent-ruby-edge
will always be 0.y.z therefore following point 4 applies "Major version zero (0.y.z) is for initial development. Anything may change at any time. The public API should not be considered stable." However we additionally use following rules:- Minor version increment means incompatible changes were made
- Patch version increment means only compatible changes were made
- Async: A mixin module that provides simple asynchronous behavior to a class. Loosely based on Erlang's gen_server.
- ScheduledTask: Like a Future scheduled for a specific future time.
- TimerTask: A Thread that periodically wakes up to perform work at regular intervals.
- Promises:
Unified implementation of futures and promises which combines features of previous
Future
,Promise
,IVar
,Event
,dataflow
,Delay
, and (partially)TimerTask
into a single framework. It extensively uses the new synchronization layer to make all the features non-blocking and lock-free, with the exception of obviously blocking operations like#wait
,#value
. It also offers better performance.
Collection classes that were originally part of the (deprecated) thread_safe
gem:
- Array A thread-safe subclass of Ruby's standard Array.
- Hash A thread-safe subclass of Ruby's standard Hash.
- Set A thread-safe subclass of Ruby's standard Set.
- Map A hash-like object
that should have much better performance characteristics, especially under high concurrency,
than
Concurrent::Hash
. - Tuple A fixed size array with volatile (synchronized, thread safe) getters/setters.
Value objects inspired by other languages:
- Maybe A thread-safe, immutable object representing an optional value, based on Haskell Data.Maybe.
Structure classes derived from Ruby's Struct:
- ImmutableStruct Immutable struct where values are set at construction and cannot be changed later.
- MutableStruct Synchronized, mutable struct where values can be safely changed at any time.
- SettableStruct Synchronized, write-once struct where values can be set at most once, either at construction or any time thereafter.
Thread-safe variables:
- Agent: A way to manage shared, mutable, asynchronous, independent state. Based on Clojure's Agent.
- Atom: A way to manage shared, mutable, synchronous, independent state. Based on Clojure's Atom.
- AtomicBoolean A boolean value that can be updated atomically.
- AtomicFixnum A numeric value that can be updated atomically.
- AtomicReference An object reference that may be updated atomically.
- Exchanger A synchronization point at which threads can pair and swap elements within pairs. Based on Java's Exchanger.
- MVar A synchronized single element container. Based on Haskell's MVar and Scala's MVar.
- ThreadLocalVar A variable where the value is different for each thread.
- TVar A transactional variable implementing software transactional memory (STM). Based on Clojure's Ref.
- See the thread pool overview, which also contains a list of other Executors available.
- CountDownLatch A synchronization object that allows one thread to wait on multiple other threads.
- CyclicBarrier A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
- Event Old school kernel-style event.
- ReadWriteLock A lock that supports multiple readers but only one writer.
- ReentrantReadWriteLock A read/write lock with reentrant and upgrade features.
- Semaphore A counting-based locking mechanism that uses permits.
- AtomicMarkableReference
Deprecated features are still available and bugs are being fixed, but new features will not be added.
Future: An asynchronous operation that produces a value.Replaced by Promises.Promise: Similar to Futures, with more features.Replaced by Promises.Delay Lazy evaluation of a block yielding an immutable result. Based on Clojure's delay.Replaced by Promises.IVar Similar to a "future" but can be manually assigned once, after which it becomes immutable.Replaced by Promises.
These are available in the concurrent-ruby-edge
companion gem.
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. Status: Partial documentation and tests; depends on new future/promise framework; stability is good.
-
Channel: Communicating Sequential Processes (CSP). Functionally equivalent to Go channels with additional inspiration from Clojure core.async. Status: Partial documentation and tests.
-
LockFreeLinkedSet Status: will be moved to core soon.
-
LockFreeStack Status: missing documentation and tests.
-
Promises::Channel A first in first out channel that accepts messages with push family of methods and returns messages with pop family of methods. Pop and push operations can be represented as futures, see
#pop_op
and#push_op
. The capacity of the channel can be limited to support back pressure, use capacity option in#initialize
.#pop
method blocks ans#pop_op
returns pending future if there is no message in the channel. If the capacity is limited the#push
method blocks and#push_op
returns pending future. -
Cancellation The Cancellation abstraction provides cooperative cancellation.
The standard methods
Thread#raise
ofThread#kill
available in Ruby are very dangerous (see linked the blog posts bellow). Therefore concurrent-ruby provides an alternative.- https://jvns.ca/blog/2015/11/27/why-rubys-timeout-is-dangerous-and-thread-dot-raise-is-terrifying/
- http://www.mikeperham.com/2015/05/08/timeout-rubys-most-dangerous-api/
- http://blog.headius.com/2008/02/rubys-threadraise-threadkill-timeoutrb.html
It provides an object which represents a task which can be executed, the task has to get the reference to the object and periodically cooperatively check that it is not cancelled. Good practices to make tasks cancellable:
- check cancellation every cycle of a loop which does significant work,
- do all blocking actions in a loop with a timeout then on timeout check cancellation and if ok block again with the timeout
-
Throttle A tool managing concurrency level of tasks.
-
ErlangActor Actor implementation which precisely matches Erlang actor behaviour. Requires at least Ruby 2.1 otherwise it's not loaded.
-
WrappingExecutor A delegating executor which modifies each task before the task is given to the target executor it delegates to.
- MRI 2.2 and above
- Latest JRuby 9000
- Latest TruffleRuby
The legacy support for Rubinius is kept for the moment but it is no longer maintained and is liable to be removed. If you would like to help please respond to #739.
Everything within this gem can be loaded simply by requiring it:
require 'concurrent'
Requiring only specific abstractions from Concurrent Ruby is not yet supported.
To use the tools in the Edge gem it must be required separately:
require 'concurrent-edge'
If the library does not behave as expected, Concurrent.use_stdlib_logger(Logger::DEBUG)
could
help to reveal the problem.
gem install concurrent-ruby
or add the following line to Gemfile:
gem 'concurrent-ruby', require: 'concurrent'
and run bundle install
from your shell.
The Edge gem must be installed separately from the core gem:
gem install concurrent-ruby-edge
or add the following line to Gemfile:
gem 'concurrent-ruby-edge', require: 'concurrent-edge'
and run bundle install
from your shell.
Potential performance improvements may be achieved under MRI by installing optional C extensions.
To minimise 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 gem too:
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.
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.
- Recent CRuby
- JRuby,
rbenv install jruby-9.2.17.0
- Set env variable
CONCURRENT_JRUBY_HOME
to point to it, e.g./usr/local/opt/rbenv/versions/jruby-9.2.17.0
- Install Docker, required for Windows builds
- Update
version.rb
- Update the CHANGELOG
- Update the Yard documentation
- Add the new version to
docs-source/signpost.md
. Needs to be done only if there are visible changes in the documentation. - Run
bundle exec rake yard
to update the master documentation and signpost. - Run
bundle exec rake yard:<new-version>
to add or update the documentation of the new version.
- Add the new version to
- Commit (and push) the changes.
- Use
be rake release
to release the gem. It consists of['release:checks', 'release:build', 'release:test', 'release:publish']
steps. It will ask at the end before publishing anything. Steps can also be executed individually.
- Chris Seaton — Lead maintainer, point-of-contact.
- Benoit Daloze — If Chris is not available Benoit can help.
- Jerry D'Antonio for creating the gem
- Brian Durand for the
ref
gem - Charles Oliver Nutter for the
atomic
andthread_safe
gems - thedarkone for the
thread_safe
gem
to the past maintainers
and to Ruby Association for sponsoring a project "Enhancing Ruby’s concurrency tooling" in 2018.
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.