Trên GitHub, ruby-concurrency/concurrent-ruby đã đạt 5.8k sao, nhóm Backend, ngôn ngữ Ruby. Modern concurrency tools including agents, futures, promises, thread pools, supervisors, and more. Inspired by Erlang, Clojure, Scala, Go, Java, JavaScript, and classic concurrency patterns.
Tóm tắt dựng từ metadata GitHub của chính dự án — chưa có bài review TopGit. Trang sẽ tự động cập nhật khi bài review đầy đủ được xuất bản.
VÌ SAO CHƯA CÓ REVIEW
TopGit viết bài đầy đủ cho repo có nhiều sao nhất và được yêu cầu nhiều nhất. Trang này là snapshot trong thời gian chờ — xem README gốc ở tab READ ME.
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
Contributing
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.
Thread Safety
Concurrent Ruby makes one of the strongest thread safety guarantees of any Ruby concurrency
library, providing consistent behavior and guarantees on all three main Ruby interpreters
(MRI/CRuby, JRuby, 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 the memory model of Ruby which
would provide consistent behaviour and guarantees on all three main Ruby interpreters
(MRI/CRuby, JRuby, TruffleRuby).
Features & Documentation
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).
Versioning
concurrent-ruby uses Semantic Versioning
concurrent-ruby-ext has always same version as concurrent-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
General-purpose Concurrency Abstractions
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.
Thread-safe Value Objects, Structures, and Collections
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.
Java-inspired ThreadPools and Other Executors
See the thread pool
overview, which also contains a list of other Executors available.
Thread Synchronization Classes and Algorithms
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
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.
.dataflow:
Built on Futures, Dataflow allows you to create a task that will be scheduled when all of
its data dependencies are available. 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.
Edge Features
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 (they 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.
LazyRegister
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 of Thread#kill available in Ruby
are very dangerous (see linked the blog posts bellow).
Therefore concurrent-ruby provides an alternative.
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.
Supported Ruby versions
MRI 2.3 and above
Latest JRuby 9000
Latest TruffleRuby
Usage
Everything within this gem can be loaded simply by requiring it:
require 'concurrent'
You can also require a specific abstraction part of the public documentation since concurrent-ruby 1.2.0, for example:
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.
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 the gem
Requirements
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 or Podman, required for Windows builds
If bundle config get path is set, use bundle config set --local path.system true otherwise the gem name, path: '.' gems won't be found (Bundler limitation).
Publishing the Gem
Update version.rb.
Update the CHANGELOG with a section for the new version linking to its GitHub release notes.
Add the new version to docs-source/signpost.md. Needs to be done only if there are visible changes in the documentation.
Commit (and push) the changes.
Use bundle exec 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.
Maintainers
Benoit Daloze
Matthew Draper
Rafael França
Charles Oliver Nutter
Ben Sheldon
Samuel Williams
Joshua Young
Special Thanks to
Jerry D'Antonio for creating the gem
Brian Durand for the ref gem
Charles Oliver Nutter for the atomic and thread_safe gems
thedarkone for the thread_safe gem
to the past maintainers
Chris Seaton
Petr Chalupa
Michele Della Torre
Paweł Obrok
Lucas Allan
and to Ruby Association for sponsoring a project
"Enhancing Ruby’s concurrency tooling" in 2018.
License and Copyright
Concurrent Ruby is free software released under the
MIT License.
ruby-concurrency/concurrent-ruby thuộc nhóm Backend trên TopGit, cùng 2 topic GitHub. Trang Trending và Topics liệt kê các repo cùng số sao và cùng ngôn ngữ để so sánh.
Đọc thêm về ruby-concurrency/concurrent-ruby ở đâu?
Trang TopGit này là một snapshot — tab "Readme" hiển thị nguyên văn README của repo (đã bỏ link, giữ ảnh). Repo GitHub ở github.com/ruby-concurrency/concurrent-ruby là nguồn chính thức.
ruby-concurrency/concurrent-ruby có bao nhiêu sao?
ruby-concurrency/concurrent-ruby có 5.8k sao GitHub — tải lại trang để xem số mới nhất, hoặc xem trực tiếp github.com/ruby-concurrency/concurrent-ruby. TopGit phản chiếu số sao của GitHub nhưng không cam kết đến từng phút.
ruby-concurrency/concurrent-ruby có phải mã nguồn mở không?
TopGit chưa ghi nhận license cho ruby-concurrency/concurrent-ruby. Phần lớn repo public trên GitHub là mã nguồn mở, nhưng điều khoản khác nhau từng repo — mở file LICENSE để xác nhận.
ruby-concurrency/concurrent-ruby còn đang phát triển không?
Commit gần nhất trên ruby-concurrency/concurrent-ruby là 4 tháng trước (theo timestamp GitHub). Repo có 424 fork — một chỉ báo về mức độ quan tâm của cộng đồng.
ruby-concurrency/concurrent-ruby là gì?
ruby-concurrency/concurrent-ruby (ruby-concurrency/concurrent-ruby) là dự án Ruby trên GitHub. Theo mô tả gốc: Modern concurrency tools including agents, futures, promises, thread pools, supervisors, and more. Inspired by Erlang, Clojure, Scala, Go, Java, JavaScript, and classic concurrency patterns.
ruby-concurrency/concurrent-ruby viết bằng ngôn ngữ gì?
ruby-concurrency/concurrent-ruby chủ yếu viết bằng Ruby. Trường "language" của GitHub dựa trên phần lớn byte ở nhánh mặc định.
Đọc đầy đủ README ở tab phía trên.
concurrent-ruby có đáng để bạn bỏ thời gian?
ChatGPT, Claude và Perplexity đều đọc được trang này. Hỏi thử xem họ nghĩ gì về concurrent-ruby.