-
parking_lot
More compact and efficient implementations of the standard synchronization primitives
-
rayon
Simple work-stealing parallelism for Rust
-
crossbeam-channel
Multi-producer multi-consumer channels for message passing
-
parking_lot_core
An advanced API for creating custom synchronization primitives
-
crossbeam-utils
Utilities for concurrent programming
-
crossbeam
Tools for concurrent programming
-
lock_api
Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.
-
specs
Specs is an Entity-Component System library written in Rust
-
tokio-threadpool
A task scheduler backed by a work-stealing thread pool
-
spin
Synchronization primitives based on spinning. They may contain data, are usable without
std, and static initializers are available -
crossbeam-epoch
Epoch-based garbage collection
-
tokio-executor
Future execution primitives
-
evmap
A lock-free, eventually consistent, concurrent multi-value map
-
crossbeam-deque
Concurrent work-stealing deque
-
shred
Dispatches systems in parallel which need read access to some resources, and write access to others
-
thread_local
Per-object thread-local storage
-
scoped_threadpool
A library for scoped and cached threadpools
-
bus
A lock-free, bounded, single-producer, multi-consumer, broadcast channel
-
nakadion
A connector for the Nakadi Event Broker
-
workerpool
A thread pool for running a number of jobs on a fixed set of stateful worker threads
-
may
Rust Stackful Coroutine Library
-
may_queue
May’s internal queue library
-
cortex-m-rtfm
Real Time For the Masses (RTFM): a concurrency framework for building real time systems
-
mpi
Message Passing Interface bindings for Rust
-
session_types
An implementation of session types in Rust
-
rustacuda
CUDA Driver API Wrapper
-
atomic
Generic Atomic wrapper type
-
crossbeam-queue
Concurrent queues
-
shred-derive
Custom derive for shred
-
rayon-core
Core APIs for Rayon
-
region
A library for manipulating memory regions
-
bus_queue
Lock-free Bounded non-Blocking Pub-Sub Queue
-
desync
A hassle-free data type for asynchronous programming
-
qutex
Synchronization mechanisms that rely on lock-free and other non-(thread)blocking techniques, such as Rust futures, to guarantee mutually exclusive or shared exclusive access to data
-
threadpool
A thread pool for running a number of jobs on a fixed set of worker threads
-
thread-id
Get a unique thread ID
-
ratelimit
a token bucket ratelimiter
-
want
Detect when another Future wants a result
-
rustc-rayon
Simple work-stealing parallelism for Rust - fork for rustc
-
movie
An actor / thread orchestration library / macro / framework
-
faster-rs
Rust wrapper for FASTER by Microsoft Research
-
chashmap
Fast, concurrent hash maps with extensive API
-
rustc-rayon-core
Core APIs for Rayon - fork for rustc
-
hurdles
Counter-based thread barrier
-
heaparray
Flexible support for dynamically sized types, using heap-allocated array of structs
-
pinboard
A lock-free, threadsafe way to publish data, just stick it on the pinboard
-
double-checked-cell
A thread-safe lazily initialized cell using double-checked locking
-
ringbuf
Lock-free SPSC FIFO ring buffer with direct access to inner data
-
hopper
an unbounded mpsc with bounded memory
-
ocl-core
A low-level OpenCL API
-
ndarray-parallel
Parallelization for ndarray (using rayon)
-
hey_listen
An event-dispatcher-collection offering sync, parallel, and prioritised solutions!
-
multiqueue2
A fast mpmc broadcast queue
-
scheduled-thread-pool
A scheduled thread pool
-
acto-rs
Experimental actor library, under development. (renamed from minions_rs).
-
try-lock
A lightweight atomic lock
-
synchronoise
Synchronization primitives that build upon the standard library
-
lossyq
This is a concurrent single publisher, single consumer queue with fixed length, that never blocks the writer
-
thread_tryjoin
Try joining a thread
-
pond
A library for scoped and cached threadpools that keep a state
-
mpmc-scheduler
multi-mpmc, cancellable, scheduler with rate limiting
-
tokenlock
Send-able cell type whose contents can be accessed only via an inforgeable token
-
jobpool
A simple and lightweight threadpool implementation
-
apodize
simple iterators that yield generalized cosine, hanning, hamming, blackman, nuttall and triangular windows
-
parallel-iterator
Parallelize any iterator with ease!
-
npnc
Lock-free queues
-
atomic_refcell
Threadsafe RefCell
-
atomic-counter
Atomic (thread-safe) counters for Rust
-
carboxyl
Library for functional reactive programming
-
smartpool
A very customizable, future-aware threadpool
-
efflux
Easy MapReduce and Hadoop Streaming interfaces in Rust
-
stm
Implementation of Software transactional memory. Allows composable atomic operations.
-
context
Cooperative multitasking for Rust using Boost.Context
-
glock
Granular locking crate for Rust
-
multiqueue
A fast mpmc broadcast queue
-
executors
A collection of high-performance task executors
-
membarrier
Process-wide memory barrier
-
ccl
Fast datastructures for use in highly concurrent systems
-
loom
Model checker for concurrent code
-
spsc-bip-buffer
A concurrent, spsc ring-buffer with sized reservations
-
deque
A (mostly) lock-free concurrent work-stealing deque
-
recycler
A small Rust library for recycling types containing owned memory
-
archery
Abstract over the atomicity of reference-counting pointers
-
coroutine
Coroutine Library in Rust
-
rcu_cell
a lockless rcu cell implementation
-
lockfree
This crate provides concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers
-
queuecheck
A thread-safe queue testing and benchmarking library
-
single_value_channel
Concurrent single-value update and receive channel
-
evc
Eventually consistent synchronization primitive
-
rayon-futures
Futures integration into Rayon
-
flo_stream
Pubsub and related streams for Rust futures
-
may_actor
Simple Actor library based on MAY
-
specs-static
specs-static is an extension for Specs that adds custom ids
-
testbench
Testing and benchmarking tools for concurrent Rust code
-
stateright
A library for specifying state machines and model checking invariants
-
guardian
Provides owned mutex guards for refcounted mutexes
-
qadapt-spin
Synchronization primitives based on spinning. They may contain data, are usable without
std, and static initializers are available -
remutex
Recursive mutex, adapted from Rust’s standard library
-
concurrent-hashmap
A concurrent hashmap library
-
tange
Scalable Task-based Parallelism Framework
-
may_waiter
Simple coroutine communication blocker
-
sealrs
Set of classic asynchronous primitives (Actors, Executors, Futures / Promises)
-
par-map
Parallel map and flat_map
-
send-cell
Immutable memory region with runtime Send checking
-
jobsteal
A work-stealing fork-join threadpool written in Rust
-
object-pool
A thread-safe object pool with automatic return and attach/detach semantics
-
blackhole
…to throw your threads into
-
brutils
Some utilities for Rust
-
priomutex
A mutex where waiting threads specify a priority
-
triomphe
A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)
-
spmc
Simple SPMC channel
-
funfsm
An FSM library where the states are functions
-
dynpool
A thread manager that is lightweight, flexible, and rescalable
-
mioco
Scalable, asynchronous IO coroutine-based handling (aka MIO COroutines)
-
atomic_immut
Atomic immutable value
-
eventbus
Safe, fast and concurrent event system, inspired by the MinecraftForge event bus
-
inert
Inert lets you use non-Sync values in a Sync way
-
generic-channel
Generic
SenderandReceiverabstract between several channel implementations: std, crossbeam-channel, futures -
tange-collection
Dataflow computation
-
mpmc
copy-pasted from old rust stdlib
-
pipeliner
Provides a nice interface for parallel programming with iterators
-
arbalest
Like Arc but where weak references don’t forbid mutable access
-
sched-clock
A timer for task scheduling
-
cbloom
Concurrent implementation of Bloom filters
-
seal_rs
Set of classic asynchronous primitives (Actors, Executors, Futures / Promises)
-
concurrent_prime_sieve
Tools for generating filters and collections with primes concurrently. Rust implementation of the Sieve of Atkin. This implementation runs in O( sqrt(max_num) + section_size ) (where section_size = max_num - min_num). Integrated with primal for increased speed in some cases.
-
parallel-event-emitter
Parallel Event Emitter for concurrent listener invocation based on futures-rs and futures-cpupool
-
context-coroutine
This is a simple set of extensions to provide stackful coroutines; it is not officially associated with the context crate
-
contrie
Concurrent map and set
-
eventual
Future & Stream abstraction
-
ice-threads
Lightweight Thread pool implementation
-
hazard
Hazard pointers
-
bi
Simple kit for reading/writing resources
-
forkjoin
A work stealing fork-join parallelism library for Rust
-
bchannel
A better channel API
-
nfqueue
Netfilter NFQUEUE high-level bindings
-
cpu-affinity
Cross-Platform CPU affinity
-
slog-atomic
Atomic run-time controllable drain for slog-rs
-
namedlock
Namespaces for named locks
-
syncbox
Concurrency utilities for Rust
-
scheduler
Binding to set the linux scheduler (priority, policy, affinity, &c.)
-
swapper
Swap ownership between threads
-
mpi-sys
Message Passing Interface bindings for Rust
-
poolite
A lite threadpool library
-
monitor
Monitor synchronization construct
-
ring-channel
Never blocking, bounded MPMC channel abstraction on top of a ring buffer
-
atomic-array
Defines several array types in which elements may be updated atomically. Intended to provide atomic array types similar to those found in java.util.concurrent.atomic in Java.
-
ordered-parallel-iterator
Performs tasks in parallel returning completed tasks in order of appearance
-
rad
A type-safe, high-level interface to librados using the low-level C bindings from ceph-rust
-
shared-expiry-get
Simple concurrent async get with expiration for Rust