Lib.rs

parking_lot

More compact and efficient implementations of the standard synchronization primitives

spin

Spin-based synchronization primitives

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

guardian

owned mutex guards for refcounted mutexes

maitake-sync

No-std async synchronization primitives from Maitake

bach

Discrete-event simulation environment for async workflows

azalea

A framework for creating Minecraft bots

lock_api

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

mutex

An abstraction over closure-based mutexes

keepcalm

shared types for multi-threaded programs

mcslock

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

async-mutex

Async mutex

happylock

Free deadlock prevention

qubit-lock

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

instance-copy-on-write

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

tracing-mutex

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

wasm_safe_thread

Cross-platform std::thread + std::sync replacement for native and wasm32

crossync

A fast concurrent programming suite for Rust

xutex

an extremely fast async mutex with alternative sync API

mutex-traits

An abstraction over closure-based mutexes

wasm_safe_mutex

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

lockable

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

ax-sync

ArceOS synchronization primitives

no_deadlocks

A Runtime Deadlock Debugger

wdk-mutex

An idiomatic Rust mutex type for Windows kernel driver development

cynosure

High performance data structures & primitives from beyond the Blackwall

tg-rcore-tutorial-sync

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

mintex

minimal mutex

surelock

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

range-lock

Range lock for std::vec::Vec

filelock

Cross-platform file locking library for Rust

rustix-futex-sync

Linux futex-based synchronization

lfrlock

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

dportable

Portable interface for various utilities

rust_web_crawler

A short summary of what your crate does

steppe

Follow the progress of a task easily

octostore

Distributed locking as a service — one binary, simple HTTP API, SQLite persistence, optional GitHub OAuth

awaiter_set

Zero-allocation awaiter tracking for async synchronization primitives

async-priority-lock

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

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

basic-mutex

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

synchronized-writer

A tiny implement for synchronously writing data

range-mutex

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

fmutex

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

rlock

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

rav1d-disjoint-mut

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

keyed-lock

A keyed lock for synchronization

tui_lib

Be the base of a Tui Operation

bilock

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

sharded_mutex

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

k-lock

A fast mutex for short critical sections

async-rwlock

Async reader-writer lock

libpetri-verification

Formal verification for libpetri Coloured Time Petri Net engine

global_counter

Global, thread-safe counters

local_async_utils

single-threaded async programming

distributed-lock-mongo

MongoDB backend for distributed locks using atomic updates and TTL indexes

ruspiro-lock

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

xiaoyong-value

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

tg-sync

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

antidote

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

wrapit

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

orchestrator_lock

A Mutex whose access order is managed by a separate thread

tokio-multilock

Deadlock-safe concurrent lock acquisition

one-shot-mutex

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

tokio-multi-lock

Deadlock-safe concurrent lock acquisition

re_mutex

A wrapper around parking_lot::Mutex useful for debugging deadlocks

run_every

Run some code up to once per specified duration

distributed-lock-mysql

MySQL backend for distributed locks using GET_LOCK/RELEASE_LOCK functions

access-cell

A cell that allows re-entrant mutable access without deadlock

distributed-lock-postgres

PostgreSQL backend for distributed locks using advisory locks

usync

fast, drop-in, synchronization primitives

eventbus-memory

In-process StreamBackend for testing the event bus

bma-benchmark

Benchmark for Rust and humans

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

bolt

The package provides a hierarchical read-write lock

forrust_fire_tracing

Tracing integration for forrust_fire_tree

rok-lock

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

nospin

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

esp-sync

Synchronization primitives for Espressif devices

clhlock

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

globals

Painless global variables in Rust

wasefire-sync

Portable non-blocking mutex

distributed-lock-file

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

axsync

ArceOS synchronization primitives

lock-hierarchy

Prevent dead locks by enforcing lock hierarchies

lazymut

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

lockless-datastructures

A bunch of lockless datastructures

parking_lot_core

An advanced API for creating custom synchronization primitives

peace-lock

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

little-sync

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

synctools

Synchronization tools for no_std

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.

unlock

Instrumented synchronization primitives helping you to unlock performance issues

rusturnate

A sync or async mutex, with or without timeouts

facet-maybe-mut

abstract away lock primitives in facet

classic-sync

ReentrantLock, Semaphore and CyclicBarrier using Classic Linux Mutex systems

nimbusqueue

fifo collection

armc

that facilitates Mutex access to variables

td_rthreadpool

thread wrapper for Rust

lamlock

MCS-style flat-combining mutex with panic-awareness

mbarc-map

Minimally-blocking, Atomic Reference Counted Map

shared-struct

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

mutex-trait

Foundational mutex trait and helpers

slock

An async mutex that never deadlocks

dome-ledger

Hash-chained audit logging with multiple sinks for Thunder Dome

fast-async-mutex

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

lockpool

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

chenzt23-tg-rcore-tutorial-sync

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

aura-zones

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

jiaxin2006-tg-rcore-tutorial-sync-t1l5

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

borrow_mutex

Async Rust Mutex which does not require wrapping the target structure

semalock

concurrently writing to files in a safe and efficient manner

shared-mutex

A RwLock that can be used with a Condvar

tg-rcore-tutorial-sync-T3L8

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

rtfm-core

Core abstractions of the Real Time For the Masses framework

one_at_a_time_please

For serialising calls to functions

parking_lot_rt

Parking-lot fork for real-time applications

simplelock

abstractions for inter-process synchronization

mutex_trait2

Generic mutex trait

sync_2

A little crate providing a Rust implemented Mutex and RwLock

syncrs

spinlock-based syncronization primitives for no_std enviroments

sync-no-std

Cross-platform interface to the synchronization primitives

lazy_mut

Alternative to LazyLock<Mutex<T>>

pi_stash

thread-checked-lock

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

cooptex

Deadlock free Mutexes

dir-lock

file-system-based mutex

remutex

Recursive mutex, adapted from Rust's standard library

spinning

Mutexes and SIX locks implemented by spinning

process-sync

Synchronization primitives for multiprocess environments

with_lock

Deadlock freedom

shared-lock

A lock that protects multiple objects at once

putex

process mutex

redis-lock

distributed locking backed by Redis

pcp-mutex

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

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

deadlocker

Bringing builder pattern to defeat deadlocks

tokio_mutex_lint

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

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

scoped-mutex-traits

An abstraction over closure-based mutexes

atrilocks

collection of light weight async synchronization primitives based on atomics

namedlock

Namespaces for named locks

dropcatch

Drop detection library for Rust

simple-mutex

A mutex more efficient than std and simpler than parking_lot

critical-section-lock-mut

Provide locks for mutable data using critical-section crate

nix-ipc

Unix interprocess communication

rufutex

Ulrich Drepper's mutex using futex implementation in Rust

chainmap

mutability of intermediate maps

priomutex

A mutex where waiting threads specify a priority

option-lock

mutex for Option values

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

linux-interprocess

Linux IPC, currently only supports mutexes

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

waithandle

that makes signaling between threads a bit more ergonomic

atomic_pincell

Threadsafe pinnable RefCell

mutex_logger

logger that usess mutex for thread safty

raliguard

Lazy rate limit semaphore implementation for your asynchronous code frequency execution

pinned-mutex

Mutex wrappers with structural pinning

simple-rw-global

GlobalContainer based on std::sync::RwLock

ref-kman

Shared reference like Mutex

mutex-timeouts

let you specify a timeout on a mutex lock

pinnable

A Mutex that can be pinned

oncemutex

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

thread-owned-lock

Mutex which can only be unlocked by the owning thread

dfmutex

Deadlock-free Mutex locks

gmtx

Mutex that grant exclusive access to a group of members

distributed-lock-core

Core traits and types for distributed locks

nest-guard

working with nested guard-type APIs

mutex-extra

RefMutex<T> that is similar to Mutex<T> but is Sync and Send even if T isn’t Send

lock_many

Retry-based locking multiple mutexes at once

padlock

Safely acquire RwLock/Mutex locks

shared-type

Shared type alias and several traits to simplify working with Arc<Mutex<T>>

qadapt-spin

Synchronization primitives based on spinning. They may contain data, are usable without std, and static initializers are available

static_leak

Leak references with static lifetimes from static Mutexes and RwLocks

fut_rwlock

A read-write lock that is read and written via Futures

fremkit

broadcast log

hybrid-lock

A hybrid lock with optimistic locking

bobcat-sdk

codesize efficient Arbitrum Stylus SDK