ruby-concurrency/concurrent-ruby

Features

• Concurrency Libraries - A comprehensive concurrency toolkit for Ruby with thread-safe data structures and synchronization primitives.
• Future Implementations - Implements futures and promises as asynchronous value containers with chaining and composition.
• Read-Write Lock Shared Data Protection - Ships read-write locks allowing multiple concurrent readers with exclusive writer access.
• Atomic Transaction Coordinators - Provides transaction isolation guarantees to preserve data consistency across concurrent threads.
• Actor Messaging - Implements actor model messaging where isolated actors communicate asynchronously.
• Asynchronous Message Passings - Encapsulates state in actors that communicate exclusively through asynchronous messages.
• Atomic Value Wrappers - Ships atomic wrappers for booleans, numerics, and object references with compare-and-swap semantics.
• Atomic State Updates - Provides atomic state update operations with optional validation to reject invalid changes.
• Asynchronous Task Composition - Chains dependent tasks together so the output of one future feeds into the next, handling success and failure paths.
• Async Method Executions - Provides a mechanism to execute methods asynchronously on a background thread, a core concurrency pattern.
• Concurrent Task Execution - Executes blocks in separate threads via thread pools, returning futures for result retrieval.
• Applicative Task Combination - Links futures together so one task starts after another completes, supporting chaining and combination.
• Sequential Task Dependencies - Links futures so dependent tasks start only after their predecessors complete with results.
• Thread-Safe Communication Channels - Implements CSP-style channel communication with FIFO message passing and optional backpressure.
• Thread Pool Offloading - Provides a managed thread pool for offloading blocking or CPU-intensive work to background threads.
• Lock-Free Primitives - Offers lock-free atomic operations with compare-and-swap semantics for shared state.
• Atomic Thread Synchronization - Synchronizes access to shared resources using mutexes, condition variables, and atomic operations.
• Non-Blocking Lock Attempts - Implements non-blocking lock acquisition that returns immediately with a boolean instead of blocking the caller.
• Read Lock Scoped Executions - Ships read lock scoped execution that automatically acquires and releases a read lock around a block.
• Scoped Lock Executions - Provides scoped lock execution with automatic release, a fundamental concurrency pattern for safe shared state access.
• Write Lock Releases - Provides write lock release with proper wake-up of waiting threads, a key synchronization operation.
• All-Completion Synchronization - Provides a future that resolves only after all futures in a collection have resolved.
• Asynchronous Promise Interfaces - Defines a placeholder for a value that will be available later, allowing chaining of callbacks and error handling.
• Concurrent Data Structures - Provides thread-safe hash, array, and set implementations for concurrent access without race conditions.
• Async Method Invocations - Provides asynchronous method invocation on a background thread, a core concurrency pattern.
• Actor Models - Implements actor model messaging for asynchronous communication between isolated actors.
• Synchronization Primitives - Implements barriers, events, semaphores, and read-write locks for thread coordination.
• Thread Pools - Manages a pool of reusable threads to execute tasks concurrently, limiting resource usage.
• Promise-Based Chains - Provides future and promise composition for chaining asynchronous operations with error propagation.
• Thread-Safe Collection Wrappers - Provides drop-in thread-safe wrappers for Array, Hash, and Set collections.
• Actor-Based Concurrency - Provides actor-based concurrency with isolated state and asynchronous message passing.
• Futures and Promises - Ships a full future and promise system for composing non-blocking asynchronous workflows.
• Asynchronous Operation Chaining - Chains futures so the output of one async task becomes the input to the next.
• Concurrency Data Isolation - Guarantees concurrent transactions do not interfere, preserving data integrity during parallel updates.
• Asynchronous Task Execution - Provides a future-based API for executing blocks on background thread pools.
• Concurrency Semaphores - Provides a counting semaphore to limit the number of threads accessing a resource simultaneously.
• Concurrent State Coordination - Provides thread-safe data structures and synchronization primitives to protect shared state.
• Future-Based Concurrency Frameworks - Constructs futures and promises that support chaining, composition, and error propagation.
• Multiple Permit Acquisitions - Provides semaphore-based permit acquisition that blocks until the requested number of permits becomes available.
• Permit Release Operations - Implements permit release operations that return permits to a semaphore and unblock waiting threads.
• Read-Write Lock Scoped Executions - Ships a scoped lock execution pattern that automatically acquires and releases read or write locks around a block of code.
• Write Lock Block Executions - Provides a scoped write-lock execution pattern, essential for safe concurrent modifications.
• Software Transactional Memory - Implements software transactional memory with retriable transactions and automatic conflict detection.
• Configurable Worker Thread Pools - Manages configurable thread pools that reuse worker threads for concurrent task execution.
• General-Purpose Thread Pools - Provides a general-purpose thread pool executor that manages reusable worker threads for concurrent task execution.
• Recurring Task Scheduling - Ships a recurring task scheduler that runs blocks at fixed intervals on separate threads.
• Immutable Data Structures - Creates immutable structs whose fields cannot be modified after instantiation.
• Immutable Value Class Generators - Creates structs with fields set at construction that cannot be changed, ensuring thread safety.
• Thread-Safe Fixed Arrays - Ships a thread-safe fixed-size array with volatile reads and writes for concurrent access.
• Retriable Transactions - Provides retriable transaction execution that automatically replays operations upon conflict detection.
• Retriable Value Transformations - Supports atomic value transformations that automatically retry when concurrent modifications are detected.
• Thread-Safe Struct Definitions - Defines structs with thread-safe member access without requiring external synchronization.
• Write-Once Struct Members - Defines structs where each member can be assigned only once, raising errors on reassignment.
• Optional Value Types - Implements Just and Nothing containers to explicitly represent computed value presence or absence.
• Collection Parallel Processors - Applies a block to each element of a collection in parallel, collecting results into a future.
• Multi-Variable Atomic Coordination - Implements software transactional memory for coordinating concurrent changes across multiple shared variables atomically.
• Compare-and-Swap Operations - Provides compare-and-swap primitives for atomic conditional updates to shared references.
• Task Racing - Resolves a future as soon as the first among a set of futures resolves.
• Retriable - Supports atomic value transformations that automatically retry when concurrent modifications are detected.
• Interval-Based Task Execution - Supports executing a block repeatedly at a fixed interval on a background thread with configurable start delay.
• Future-Time Executions - Schedules futures to resolve at a specific time or after a configurable delay.
• Global Executor Abstractions - Provides a global, lazily-loaded thread pool for async operations with optional per-task overrides.
• Delayed Task Scheduling - Schedules blocks to run after a specified delay with manual or automatic triggering.
• Barrier Synchronization - Synchronizes groups of threads at a common barrier point before releasing them.
• Thread Barriers - Implements a thread barrier that synchronizes a group of threads at a common point before proceeding.
• Lock Upgrade and Downgrade Operations - Implements lock upgrade and downgrade operations that allow the same thread to change lock mode without deadlock.
• Non-Blocking Value Read and Write Attempts - Ships non-blocking value read and write attempts that return sentinels instead of blocking the caller.
• Thread Local Storage - Ships thread-local variable storage that isolates values per thread for safe concurrent access.
• Countdown Latches - Implements a countdown latch that blocks the calling thread until a specified number of tasks complete.
• Channel-Based Concurrency - Implements CSP-style channels with FIFO message passing and optional backpressure.
• Custom Thread Pool Configurations - Allows assigning a specific thread pool to a future or async operation, overriding the default executor.
• Scalable Thread Pools - Implements a dynamic thread pool that creates and caches worker threads as needed.
• Thread-Safe Struct Accessors - Provides thread-safe read and write access to struct members by name or index.
• First-Success Synchronization - Resolves a future with the first successfully fulfilled result among a set.
• Locking Set Wrappers - Provides a thread-safe set that locks on every method call for safe concurrent access.
• Async Error Compositions - Catches exceptions from async methods and exposes them as the reason attribute of the returned future.
• Concurrent Effect Combinators - Provides combinators to wait for multiple futures and collect their results into a single array.
• Concurrent Task Limiters - Limits concurrent task execution by assigning work to configurable thread pools.
• Manually Resolvable Futures - Ships a manually resolvable promise type that developers must explicitly fulfill or reject.
• First-Result Resolvers - Creates futures that resolve with the first result, regardless of success or failure.
• Timed Permit Acquisitions - Provides timed permit acquisition that attempts to acquire permits within a configurable timeout.
• Asynchronous Value Updates - Implements agents that dispatch update functions to background threads for asynchronous shared state modification.
• Single-Slot Synchronization Primitives - Provides single-slot synchronization primitives that block threads when reading from empty or writing to full containers.
• Coarse-Grained Hash Locking - Implements a thread-safe hash that locks the entire structure on every access.
• Concurrent Collections - Ships thread-safe hash, array, and set collections for concurrent access without race conditions.
• Fixed-Size Thread Pools - Provides a fixed-size thread pool that reuses a predetermined number of worker threads.
• Server Thread Pools - Dispatches work to a configurable pool of background threads, reusing threads to avoid creation overhead.
• Shared Executor Usage - Runs async operations on a shared, lazily-loaded executor to avoid unnecessary thread creation.
• Concurrent Future Monitoring - Resolves a future as soon as any one of a set of futures completes.
• Concurrent Error Propagation - Captures exceptions from async tasks and propagates them as rejected futures with the error reason.
• Concurrency and Parallelism - Tools for managing asynchronous tasks and thread pools.

Star-Verlauf