Lib.rs

parking_lot

More compact and efficient implementations of the standard synchronization primitives

spin

Spin-based synchronization primitives

lock_api

Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.

async-lock

Async synchronization primitives

critical-section

Cross-platform critical section

futures-intrusive

Futures based on intrusive data structures - for std and no-std environments

mea

A runtime-agnostic library providing essential synchronization primitives for asynchronous Rust programming

saa

Word-sized low-level synchronization primitives providing both asynchronous and synchronous interfaces

maitake-sync

No-std async synchronization primitives from Maitake

guardian

owned mutex guards for refcounted mutexes

aqueue

fast speed thread safe async execute queue

tracing-mutex

Ensure deadlock-free mutexes by allocating in order, or else

bach

Discrete-event simulation environment for async workflows

synchronized-writer

A tiny implement for synchronously writing data

keepcalm

shared types for multi-threaded programs

mcslock

Mellor-Crummey and Scott contention-free lock for mutual exclusion, referred to as MCS lock

happylock

Free deadlock prevention

mutex

An abstraction over closure-based mutexes

instance-copy-on-write

A MT-safe copy-on-write implementation for the data structures

async-mutex

Async mutex

qubit-lock

Lock utilities library providing synchronous, asynchronous, and monitor-based locking primitives

xutex

an extremely fast async mutex with alternative sync API

rl-core

Core logic for a token-bucket rate-limiter

cynosure

High performance data structures & primitives from beyond the Blackwall

crossync

A fast concurrent programming suite for Rust

wasm_safe_mutex

A suite of WebAssembly-safe synchronization primitives that paper over platform-specific locking constraints

wdk-mutex

An idiomatic Rust mutex type for Windows kernel driver development

ax-sync

ArceOS synchronization primitives

tg-rcore-tutorial-sync

Synchronization primitives for rCore tutorial OS, including mutex, semaphore, and condvar

mintex

minimal mutex

orlando-core

A virtual actor framework in Rust, inspired by Microsoft Orleans

no_deadlocks

A Runtime Deadlock Debugger

lockable

offers hash map, hash set and cache data structures where individual entries can be locked

awaiter_set

Zero-allocation awaiter tracking for async synchronization primitives

filelock

Cross-platform file locking library for Rust

mutex-traits

An abstraction over closure-based mutexes

faces-pfm

reference implementation of faces::AbsPageFrameManager

azalea

A framework for creating Minecraft bots

surelock

Deadlock-free locks for Rust with compile time guarantees, incremental locks, and atomic lock sets

fmutex

Cross-platform mutual exclusion across processes on a file or path

dportable

Portable interface for various utilities

rav1d-disjoint-mut

A provably safe abstraction for concurrent disjoint mutable access to contiguous storage

range-lock

Range lock for std::vec::Vec

rustix-futex-sync

Linux futex-based synchronization

lfrlock

A Lock-Free Read Lock where reads never block and writes are serialized using Mutex

facet-maybe-mut

abstract away lock primitives in facet

async-priority-lock

A priority-based async lock. Optionally no-std.

run_every

Run some code up to once per specified duration

merc_sharedmutex

A read efficient readers-writer lock based on the busy-forbidden protocol

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

range-mutex

A Mutex<[T]>-like type, that allows locking different ranges separately

rlock

Redis-backed lock library providing both async and sync Mutex, RwLock, and others

rust_web_crawler

A short summary of what your crate does

steppe

Follow the progress of a task easily

basic-mutex

A lightweight, FIFO-ordered mutex with fair scheduling and hybrid spin–park synchronization

sharded_mutex

No per-object memory overhead locks. Pseudo atomic ops for Copy/PartialEq types.

orlando-cluster

A virtual actor framework in Rust, inspired by Microsoft Orleans

local_async_utils

single-threaded async programming

ruspiro-lock

Providing Spinlock, Semaphore and mutual exclusive data access for cross core usage on Raspberry Pi

global_counter

Global, thread-safe counters

child_lock

Synchronize access to many locks using only a single parent lock

xiaoyong-value

Collection of sharing state primitives for async contexts (both Sync and !Sync)

distributed-lock-mysql

MySQL backend for distributed locks using GET_LOCK/RELEASE_LOCK functions

async-rwlock

Async reader-writer lock

wasefire-sync

Portable non-blocking mutex

tui_lib

Be the base of a Tui Operation

orlando-timers

A virtual actor framework in Rust, inspired by Microsoft Orleans

k-lock

A fast mutex for short critical sections

tg-sync

Synchronization primitives for rCore tutorial OS, including mutex, semaphore, and condvar

re_mutex

A wrapper around parking_lot::Mutex useful for debugging deadlocks

bilock

A minimal spin-lock based two-handle Arc<Mutex<T>> replacement

antidote

Poison-free versions of the standard library Mutex and RwLock types

keyed-lock

A keyed lock for synchronization

tokio-multilock

Deadlock-safe concurrent lock acquisition

agent-lock

Cooperative execution lock to prevent concurrent agent runs on the same key

orchestrator_lock

A Mutex whose access order is managed by a separate thread

tokio-multi-lock

Deadlock-safe concurrent lock acquisition

hermit-sync

Synchronization primitives for kernels

non_blocking_mutex

NonBlockingMutex is currently the fastest way to do expensive calculations under lock, or do cheap calculations under lock when concurrency/load/contention is very high

usync

fast, drop-in, synchronization primitives

wrapit

A lightweight Rust crate that wraps any variable using interior mutability (RefCell, Mutex, or RwLock) for ergonomic shared mutation

clhlock

Craig and, indenpendently, Magnussen, Landin, and Hagersten queue lock for mutual exclusion, referred to as CLH lock

sync-arena

thread-safe arena allocator

one-shot-mutex

One-shot locks that panic instead of (dead)locking on contention

forrust_fire_tracing

Tracing integration for forrust_fire_tree

nospin

containing an embedded version of a Mutex which can be used in no_std projects which are single-threaded

libpetri-verification

Formal verification for libpetri Coloured Time Petri Net engine

parking_lot_core

An advanced API for creating custom synchronization primitives

esp-sync

Synchronization primitives for Espressif devices

per-thread-mutex

Synchronization lock designed for wrapping thread-unsafe C libraries

globals

Painless global variables in Rust

axsync

ArceOS synchronization primitives

lazymut

Similar to LazyCell, but use &mut self to get or initialization

access-cell

A cell that allows re-entrant mutable access without deadlock

little-sync

A little rust crate that provides fastest sync types such as Mutex, RwLock and other

peace-lock

A zero-cost abstraction lock that helps check contention free algorithms

distributed-lock-mongo

MongoDB backend for distributed locks using atomic updates and TTL indexes

synctools

Synchronization tools for no_std

keyed-semaphore

Acquire many distinct RAII permits keyed by name, allowing only one in-flight permit per key

inflight-set

Acquire many distinct RAII guards keyed by name, allowing only one in-flight guard per key

rok-lock

Distributed lock primitives (in-memory, Redis, PostgreSQL) for the rok framework

spin-sync

Synchronization primitives using spinlock. The interface resembles std::sync. The constructors of public structs are const; i.e. it is possible to declare static Mutex<T> as long as T can be build statically.

lock-hierarchy

Prevent dead locks by enforcing lock hierarchies

goldielocks

Collection of common locking/signalling patterns

classic-sync

ReentrantLock, Semaphore and CyclicBarrier using Classic Linux Mutex systems

mutex-trait

Foundational mutex trait and helpers

armc

that facilitates Mutex access to variables

td_rthreadpool

thread wrapper for Rust

unlock

Instrumented synchronization primitives helping you to unlock performance issues

fast-async-mutex

lib which provide asynchronous locking mechanisms (Mutex, RwLock, OrderedMutex and OrderedRwLock)

lamlock

MCS-style flat-combining mutex with panic-awareness

distributed-lock-postgres

PostgreSQL backend for distributed locks using advisory locks

slock

An async mutex that never deadlocks

nimbusqueue

fifo collection

lock_pool

Robust, efficient, high performance, asynchronous object pooling

mbarc-map

Minimally-blocking, Atomic Reference Counted Map

shared-struct

Proc-macro for turning a struct into a shared concurrent wrapper

rusturnate

A sync or async mutex, with or without timeouts

distributed-lock-file

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

lockpool

offers a pool of locks where individual locks can be locked/unlocked by key

obsidian-scheduler

scheduling tasks with both callback and event-based timers

borrow_mutex

Async Rust Mutex which does not require wrapping the target structure

deadlocker

Bringing builder pattern to defeat deadlocks

neon-rtos

A real-time operating system for ARM Cortex-M or RISC-V microcontrollers

eventbus-memory

In-process StreamBackend for testing the event bus

bolt

The package provides a hierarchical read-write lock

semalock

concurrently writing to files in a safe and efficient manner

aura-zones

File and function ownership zones for multi-agent codebases. Mutex for AI agents — claim, detect collisions, coordinate.

lockless-datastructures

A bunch of lockless datastructures

shared-mutex

A RwLock that can be used with a Condvar

chenzt23-tg-rcore-tutorial-sync

Synchronization primitives for rCore tutorial OS, including mutex, semaphore, and condvar

rtfm-core

Core abstractions of the Real Time For the Masses framework

jiaxin2006-tg-rcore-tutorial-sync-t1l5

Synchronization primitives for rCore tutorial OS, including mutex, semaphore, and condvar

simplelock

abstractions for inter-process synchronization

one_at_a_time_please

For serialising calls to functions

tg-rcore-tutorial-sync-T3L8

Synchronization primitives for rCore tutorial OS, including mutex, semaphore, and condvar

sync_2

A little crate providing a Rust implemented Mutex and RwLock

parking_lot_rt

Parking-lot fork for real-time applications

sync-no-std

Cross-platform interface to the synchronization primitives

oncemutex

A mutex providing one-time synchronized access, then safe unsynchronized access

lazy_mut

Alternative to LazyLock<Mutex<T>>

remutex

Recursive mutex, adapted from Rust's standard library

cooptex

Deadlock free Mutexes

spinning

Mutexes and SIX locks implemented by spinning

easy_mutex

A cloneable mutex wrapper that simplifies everyday use

dir-lock

file-system-based mutex

mutex_trait2

Generic mutex trait

with_lock

Deadlock freedom

shared-lock

A lock that protects multiple objects at once

putex

process mutex

process-sync

Synchronization primitives for multiprocess environments

pcp-mutex

A Priority Ceiling Protocol (PCP) mutex, based on Linux PI futex. Allows efficient and deadlock free execution.

namedlock

Namespaces for named locks

thread-checked-lock

Gracefully error when a thread attempts to acquire the same lock twice

bastion-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

try-mutex

Fast non-blocking mutex

scoped-mutex

An abstraction over closure-based mutexes

lock_cell

A custom locking cell type written in Rust

jthread

Deadlock-free Mutual Exclusion locks for Rust

atomic_sync

Atomic-based synchronization implementing traits in abs_sync

pinned-init-macro

Proc macros for the pinned-init crate

scoped-mutex-traits

An abstraction over closure-based mutexes

critical-section-lock-mut

Provide locks for mutable data using critical-section crate

rufutex

Ulrich Drepper's mutex using futex implementation in Rust

chainmap

mutability of intermediate maps

simple-mutex

A mutex more efficient than std and simpler than parking_lot

pi_stash

waithandle

that makes signaling between threads a bit more ergonomic

priomutex

A mutex where waiting threads specify a priority

redis-lock

distributed locking backed by Redis

tomt_async

Primarily a dumping ground for personal async snippets that may be used in other ToMT projects. If this crate is useful to others please let us know.

tokio-lk

Futures-aware lock-by-id primitives

async-debug

Debug structs and enums containing values that require an async call to render

syncrs

spinlock-based syncronization primitives for no_std enviroments

linux-interprocess

Linux IPC, currently only supports mutexes

option-lock

mutex for Option values

read-write-api

interface to unify single-threaded code and RwLocks-based code

gothack-future-parking_lot

An "as simple as possible" Future implementation for parking_lot

locker

named mutex/locker for rust-lang concurrency

atomic_pincell

Threadsafe pinnable RefCell

raliguard

Lazy rate limit semaphore implementation for your asynchronous code frequency execution

dropcatch

Drop detection library for Rust

ref-kman

Shared reference like Mutex

mutex-timeouts

let you specify a timeout on a mutex lock

pinnable

A Mutex that can be pinned

thread-owned-lock

Mutex which can only be unlocked by the owning thread

mutex_logger

logger that usess mutex for thread safty

pinned-mutex

Mutex wrappers with structural pinning

nix-ipc

Unix interprocess communication

gmtx

Mutex that grant exclusive access to a group of members

nest-guard

working with nested guard-type APIs

distributed-lock-core

Core traits and types for distributed locks

tokio_mutex_lint

A dylint lint that detects tokio::sync::Mutex guards held across .await points

dfmutex

Deadlock-free Mutex locks