# Concurrency control libraries

> AI-ranked search results for `concurrency constraints` on awesome-repositories.com — ordered by an LLM for relevance, best match first. 112 total matches; showing the top 25.

Explore on the web: https://awesome-repositories.com/q/concurrency-constraints

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [this search on awesome-repositories.com](https://awesome-repositories.com/q/concurrency-constraints).**

## Results

- [actix/actix](https://awesome-repositories.com/repository/actix-actix.md) (9,223 ⭐) — Actix is a Rust actor framework and concurrent programming toolkit designed for building applications that manage state through an asynchronous messaging system. It provides a model where independent actors serve as autonomous units of state and logic, communicating via strongly typed messages sent to unique addresses.

The framework distinguishes itself by isolating state within these actors, allowing internal data to be mutated safely during message handling without the use of locks or mutexes. It employs an asynchronous mailbox system to buffer incoming requests and uses supervision strateg
- [akka/akka](https://awesome-repositories.com/repository/akka-akka.md) (13,271 ⭐) — Akka is an actor model framework and distributed systems platform used to build concurrent and distributed applications. It provides a toolkit for managing multi-threaded state and behavior through asynchronous message passing, allowing developers to create concurrent applications without manual locks or synchronization.

The system functions as a cluster management and event sourcing framework, automating the scaling and coordination of high-availability clusters. It enables the deployment of elastic services that coordinate workloads across multiple network nodes and ensures fault tolerance
- [tokio-rs/tokio](https://awesome-repositories.com/repository/tokio-rs-tokio.md) (32,309 ⭐) — Tokio is an asynchronous runtime for the Rust programming language, designed to manage and execute concurrent tasks efficiently. It provides a multi-threaded execution environment that schedules lightweight tasks across available processor cores, utilizing a work-stealing scheduler to balance computational load. By employing a poll-based execution model and waker-based notifications, the runtime drives asynchronous operations forward without requiring active polling loops, ensuring efficient resource utilization.

The project distinguishes itself through a comprehensive suite of tools for high
- [go-redsync/redsync](https://awesome-repositories.com/repository/go-redsync-redsync.md) (4,026 ⭐) — Redsync is a distributed lock manager and Go Redis client extension designed to ensure exclusive access to shared resources. It implements mutual exclusion across multiple processes by using a Redis backend to coordinate synchronization and prevent race conditions in distributed environments.

The library maintains lock validity through quorum-based consensus, requiring successful writes to a majority of independent Redis nodes. It utilizes Lua-scripted atomic operations for acquisition and release, while employing value-based ownership validation and time-to-live expiration to prevent deadloc
- [akka/akka-core](https://awesome-repositories.com/repository/akka-akka-core.md) (13,272 ⭐) — Akka Core is an actor model framework and asynchronous concurrency library used for building scalable and resilient distributed systems. It provides a distributed computing platform and fault tolerant runtime that manages communication and state across networked nodes.

The system uses location-transparent messaging and a cluster management system to organize nodes into high-availability architectures. This allows for the creation of elastic clusters that scale resources on demand and coordinate distributed workloads.

The platform handles concurrent state management and distributed systems or
- [celluloid/celluloid](https://awesome-repositories.com/repository/celluloid-celluloid.md) (3,870 ⭐) — Celluloid is a concurrent object framework for the Ruby language. It implements the actor model to enable the construction of multithreaded programs where objects communicate through asynchronous message passing to avoid shared state locks.

The framework provides a system for managing asynchronous interactions without manual locking or thread management. It utilizes actor-based object orientation to handle parallel execution and non-blocking tasks.

The project covers several architecture and capability areas, including mailbox-driven execution, fiber-based task scheduling, and proxy-based me
- [puniverse/quasar](https://awesome-repositories.com/repository/puniverse-quasar.md) (4,553 ⭐) — Quasar is a JVM concurrency framework that implements the actor model and a lightweight thread library. It provides isolated execution units that communicate via asynchronous message passing to eliminate shared mutable state.

The project distinguishes itself through a distributed actor system capable of operating across multiple cluster nodes with location-transparent registries and actor state migration. It utilizes a work-stealing fiber scheduler to manage millions of lightweight threads, allowing tasks to suspend during non-blocking I/O operations without stalling underlying system threads
- [cl0610/java-concurrency](https://awesome-repositories.com/repository/cl0610-java-concurrency.md) (4,590 ⭐) — This Java concurrency library provides a suite of tools for managing multi-threaded execution, synchronization, and memory consistency. It serves as a comprehensive framework for implementing concurrent execution through lock-free atomics, thread-safe collections, task coordination primitives, and worker pools.

The project includes a dedicated thread synchronization toolkit featuring latches, barriers, and semaphores to coordinate the timing and order of concurrent tasks. It also provides a concurrent collection suite of maps, queues, and lists that enable data sharing without manual locking,
- [ruby-concurrency/concurrent-ruby](https://awesome-repositories.com/repository/ruby-concurrency-concurrent-ruby.md) (5,830 ⭐) — Concurrent Ruby is a comprehensive concurrency toolkit for the Ruby language that provides thread-safe data structures, synchronization primitives, and asynchronous execution patterns. It implements core concurrency abstractions including an actor model framework where isolated actors communicate through asynchronous message passing, a future and promise system for composing non-blocking operations, and thread pool executors that manage reusable worker threads for concurrent task execution.

The library distinguishes itself through a broad set of coordination mechanisms that go beyond basic th
- [rayon-rs/rayon](https://awesome-repositories.com/repository/rayon-rs-rayon.md) (13,071 ⭐) — Rayon is a data parallelism library for Rust that provides a framework for converting sequential computations into parallel operations. It enables the transformation of standard data structures and loops into parallel iterators, allowing workloads to be distributed across multiple processor cores. By utilizing a work-stealing scheduler, the library dynamically balances tasks to maximize throughput and minimize execution time.

The library distinguishes itself through its focus on safe, scoped task synchronization, which ensures that all spawned operations complete before a scope exits to preve
- [asynkron/protoactor-go](https://awesome-repositories.com/repository/asynkron-protoactor-go.md) (5,469 ⭐) — protoactor-go is a framework for building concurrent and distributed systems in Go using the actor model. It provides a distributed actor system that enables isolated entities to communicate via asynchronous messaging and share state across a cluster.

The framework implements a multi-language actor protocol, allowing interoperability between actors written in Go, C#, and Java. It further supports a virtual actor implementation, where actors are automatically instantiated across a network based on a unique identity.

The system includes a supervision model for managing actor lifecycles and fau
- [lunatic-solutions/lunatic](https://awesome-repositories.com/repository/lunatic-solutions-lunatic.md) (4,867 ⭐) — Lunatic is a WebAssembly runtime and concurrent process manager that implements an Erlang-inspired model of lightweight concurrency and fault tolerance. It functions as a distributed actor system where isolated processes communicate via message passing across a network of linked nodes.

The system utilizes a WebAssembly sandbox environment to isolate memory and restrict system call permissions for each individual process. This capability-based security model ensures that processes are sandboxed to safely execute untrusted code.

The platform provides a fault-tolerant supervision tree for hiera
- [smol-rs/smol](https://awesome-repositories.com/repository/smol-rs-smol.md) (4,979 ⭐) — Smol is a lightweight Rust asynchronous runtime and task executor. It provides a suite of foundational tools for scheduling and executing asynchronous futures, managing background workloads, and handling non-blocking network and file operations.

The project includes a compatibility layer for adapting asynchronous types and execution contexts, enabling futures to run across different runtime ecosystems. It also features a mechanism to offload synchronous I/O and CPU-intensive operations to dedicated worker thread pools to prevent runtime stalls.

Its capabilities cover non-blocking network I/O
- [akkadotnet/akka.net](https://awesome-repositories.com/repository/akkadotnet-akka-net.md) (5,023 ⭐) — Akka.NET is an actor model framework used for building concurrent and distributed applications. It functions as a distributed computing platform and state manager that enables isolated actors to communicate via asynchronous message passing, ensuring thread-safe state management without manual locks.

The project is distinguished by its decentralized coordination capabilities, including a distributed state manager that uses sharding and dynamic rebalancing to maintain high availability. It incorporates an event sourcing engine that persists state as a sequence of events in an append-only log an
- [lewissbaker/cppcoro](https://awesome-repositories.com/repository/lewissbaker-cppcoro.md) (3,818 ⭐) — cppcoro is a C++ coroutine library and concurrency toolkit providing primitives for asynchronous tasks, lazy generators, and non-blocking execution. It functions as an asynchronous I/O framework for managing network sockets and file operations through an event loop.

The library features a work-stealing thread pool for distributing tasks across multiple cores and a set of async generators for producing lazy sequences of values both synchronously and asynchronously. It includes a concurrency toolkit with async mutexes, latches, and shared tasks to coordinate multi-threaded execution.

Its capab
- [zio/zio](https://awesome-repositories.com/repository/zio-zio.md) (4,347 ⭐) — ZIO is a functional effect system for the JVM that models asynchronous and concurrent programs as pure, composable values with typed error handling and dependency injection. Its core identity is built on fiber-based concurrency, where lightweight, non-blocking fibers execute millions of concurrent tasks with structured lifecycle management, and a dual-channel error model that separates expected business failures from unexpected system defects at compile time. The system provides effect-typed dependency injection through a layer-based dependency graph, pull-based reactive stream processing with
- [jctools/jctools](https://awesome-repositories.com/repository/jctools-jctools.md) (3,851 ⭐) — JCTools is a Java concurrency library providing a collection of lock-less and wait-free data structures. It serves as a toolkit for managing thread-safe data exchange, specifically designed to optimize high-throughput messaging and producer-consumer patterns in multi-threaded applications.

The library distinguishes itself by implementing specialized queue structures that minimize contention and maximize throughput. By utilizing techniques such as cache-line padding, memory-barrier-based synchronization, and relaxed-consistency memory ordering, it avoids the performance bottlenecks often assoc
- [greenrobot/eventbus](https://awesome-repositories.com/repository/greenrobot-eventbus.md) (24,760 ⭐) — EventBus is a publish-subscribe messaging library designed to facilitate decoupled communication between components in Java applications. It functions as a central hub where producers dispatch events that are routed to subscribers based on the class type of the payload. By using annotation-based markers, the system maps event handlers to specific data types, allowing different parts of an application to exchange information without requiring direct references between classes.

The library distinguishes itself through a focus on performance and execution control. It utilizes a compile-time inde
- [apple/swift-atomics](https://awesome-repositories.com/repository/apple-swift-atomics.md) (1,195 ⭐) — Swift Atomics is a library providing low-level primitives for thread-safe memory operations within the Swift programming language. It serves as a toolkit for concurrent programming, enabling the development of data structures that manage shared memory access across multiple execution contexts without relying on traditional software locks.

The library distinguishes itself by providing type-safe wrappers that encapsulate raw memory storage, ensuring that shared data remains protected while preventing accidental non-atomic access. It utilizes hardware-mapped intrinsics and compiler-integrated me
- [kraken-php/framework](https://awesome-repositories.com/repository/kraken-php-framework.md) (1,104 ⭐) — This framework is a distributed systems runtime designed for building fault-tolerant, message-driven microservices and high-performance network applications in PHP. It provides an asynchronous execution environment that utilizes event-loop-based concurrency and promise-based task orchestration to manage high-concurrency workloads without blocking execution threads.

The platform distinguishes itself through a unified execution abstraction that manages multi-process and multi-threaded components as isolated, supervised containers. By employing an actor-model approach to process supervision, the
- [gevent/gevent](https://awesome-repositories.com/repository/gevent-gevent.md) (6,440 ⭐) — Gevent is a Python coroutine concurrency library and asynchronous task manager designed for high-concurrency I/O tasks. It provides a cooperative networking framework for building asynchronous TCP, UDP, and HTTP servers, as well as a WSGI web server implementation for hosting web applications.

The project is distinguished by its standard library monkey-patching tool, which replaces blocking synchronous functions with cooperative versions to enable asynchronous behavior in third-party code. This allows for a cooperative multitasking workflow where the system yields execution during I/O waits t
- [typelift/concurrent](https://awesome-repositories.com/repository/typelift-concurrent.md) (208 ⭐) — Functional Concurrency Primitives
- [modern-go/concurrent](https://awesome-repositories.com/repository/modern-go-concurrent.md) (306 ⭐) — concurrency utilities
- [tejzpr/ordered-concurrently](https://awesome-repositories.com/repository/tejzpr-ordered-concurrently.md) (46 ⭐) — Ordered-concurrently a library for concurrent processing with ordered output in Go. Process work concurrently and returns output in a channel in the order of input. It is useful in concurrently processing items in a queue, and get output in the order provided by the queue.
- [didactic-drunk/concurrent.cr](https://awesome-repositories.com/repository/didactic-drunk-concurrent-cr.md) (50 ⭐) — Modern concurrency tools for Crystal