Concurrency

Rendezvous hashing with support for tag-based exclusions

Parallel Event Emitter for concurrent listener invocation based on futures-rs and futures-cpupool

Common components for the `deploy` and `fabric` crates.

A Tokio-based asynchronous runtime

Generic Publish / Subscribe model for application messaging

A Rust Redlock implementation for distributed, highly-available redis locks

Lock-free concurrent hash map: elements never move after insertion, enabling lock-free reads

A fast mpmc broadcast queue

Composable, lock-free, allocation-light data structures

Single and multi-threaded task scheduler

Lock-free SPSC and MPSC byte ring buffers for logging and archival

A synchronization primitive for unlimited lock-free reads with one concurrent writer.

Memory order consume for when it's known that the compiler can't elide the dependency

Various ways of stopping threads on various platforms, without requiring the thread to poll.

High-performance, schema-agnostic, backend-agnostic event bus

A thread manager that is lightweight, flexible, and rescalable.

The `deploy` library to aide writing and debugging of distributed programs, as well as tooling to run them across a cluster.

A single-threaded busy-wait executor based on futures

Redis job queue

easyfibers is a closure-less couroutine library for executing asynchronous tasks as painlessly as possible.

A barrier for blocking a main thread until the completion of work which has been offloaded to worker threads, without blocking the worker threads.

Implicitly await calls returning Future impls

Cross-process named locks using std::fs::File::lock() on Unix and CreateMutexW on Windows

Core traits and types for distributed locks

transaction abstraction of stm

Set of connectors for MEIO framework

A thread pool for running a number of jobs on a fixed set of worker threads.

Primitives for generic lazy evaluation in Rust. This crate requires nightly for `untagged_unions`.

A concurrent unbounded blocking queue where each element can only be removed when its delay expires.

A toolkit for GLSL-Rust interop

Inert lets you use non-Sync values in a Sync way

Prevent false sharing between data

A type-safe, high-level interface to librados using the low-level C bindings from ceph-rust.

A concurrent, spsc ring-buffer with sized reservations

Object pool types useful for FFI code.

Async watch channel

A struct which allows multiple threads to safely update and read from a shared non-nullable pointer to heap data

Provides macro attributes that translate existing code to be parallel using rayon.

Parallelize any iterator with ease!

Examples of extending meio

A simple, cancelable timer with no external dependencies

Clean abstraction for a single-threaded event loop. Built as a lightweight wrapper around the std::sync::mpsc package.

File system backend for distributed locks using OS-level file locking

MySQL backend for distributed locks using GET_LOCK/RELEASE_LOCK functions

Redis backend for distributed locks with RedLock algorithm support

A thread pool which agressively terminates its threads as soon as they are idle.

Garbage Collector(Hyaline- Safe Memory Reclaimation) for lock free data structures

Parallel iterator adaptors that accept arbitrary iterators

Implementation of Software transactional memory. STM Allows composable atomic operations. STM-core implements the bare bones of stm usage. The STM crate adds useful data structures.

A concurrent bag datastructure.