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

maitake-sync

No-std async synchronization primitives from Maitake

saa

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

guardian

owned mutex guards for refcounted mutexes

mutex

An abstraction over closure-based mutexes

keepcalm

shared types for multi-threaded programs

piper

Async pipes, channels, mutexes, and more

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.

wasm_safe_mutex

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

happylock

Free deadlock prevention

tracing-mutex

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

instance-copy-on-write

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

mutex-traits

An abstraction over closure-based mutexes

mcslock

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

async-mutex

Async mutex

xutex

an extremely fast async mutex with alternative sync API

no_deadlocks

A Runtime Deadlock Debugger

crossync

A fast concurrent programming suite for Rust

lockable

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

rust_web_crawler

A short summary of what your crate does

mintex

minimal mutex

wdk-mutex

An idiomatic Rust mutex type for Windows kernel driver development

lfrlock

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

axsync

ArceOS synchronization primitives

range-lock

Range lock for std::vec::Vec

rav1d-disjoint-mut

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

synchrony

that provides both sync and unsync versions of common synchronization primitives

wasefire-sync

Portable non-blocking mutex

rustix-futex-sync

Linux futex-based synchronization

cynosure

High performance data structures & primitives from beyond the Blackwall

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

filelock

Cross-platform file locking library for Rust

fmutex

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

wrapit

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

steppe

Follow the progress of a task easily

k-lock

A fast mutex for short critical sections

async-rwlock

Async reader-writer lock

tui_lib

Be the base of a Tui Operation

global_counter

Global, thread-safe counters

one-shot-mutex

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

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

synchronized-writer

A tiny implement for synchronously writing data

keyed-lock

A keyed lock for synchronization

sharded_mutex

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

distributed-lock-mongo

MongoDB backend for distributed locks using atomic updates and TTL indexes

orchestrator_lock

A Mutex whose access order is managed by a separate thread

bolt

The package provides a hierarchical read-write lock

sync-no-std

Cross-platform interface to the synchronization primitives

ruspiro-lock

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

antidote

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

local_async_utils

single-threaded async programming

dportable

Portable interface for various utilities

access-cell

A cell that allows re-entrant mutable access without deadlock

hermit-sync

Synchronization primitives for kernels

lockless-datastructures

A bunch of lockless datastructures

clhlock

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

distributed-lock-mysql

MySQL backend for distributed locks using GET_LOCK/RELEASE_LOCK functions

globals

Painless global variables in Rust

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

fast-async-mutex

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

lamlock

MCS-style flat-combining mutex with panic-awareness

usync

fast, drop-in, synchronization primitives

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

distributed-lock-postgres

PostgreSQL backend for distributed locks using advisory locks

distributed-lock-file

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

forrust_fire_tracing

Tracing integration for forrust_fire_tree

unlock

Instrumented synchronization primitives helping you to unlock performance issues

td_rthreadpool

thread wrapper for Rust

lock-hierarchy

Prevent dead locks by enforcing lock hierarchies

easy_mutex

A cloneable mutex wrapper that simplifies everyday use

mbarc-map

Minimally-blocking, Atomic Reference Counted Map

nimbusqueue

fifo collection

rusturnate

A sync or async mutex, with or without timeouts

pi_stash

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

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.

dropcatch

Drop detection library for Rust

parking_lot_core

An advanced API for creating custom synchronization primitives

mutex_trait2

Generic mutex trait

tg-sync

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

classic-sync

ReentrantLock, Semaphore and CyclicBarrier using Classic Linux Mutex systems

syncrs

spinlock-based syncronization primitives for no_std enviroments

armc

that facilitates Mutex access to variables

lazymut

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

atrilocks

collection of light weight async synchronization primitives based on atomics

mutex-trait

Foundational mutex trait and helpers

re_mutex

A wrapper around parking_lot::Mutex useful for debugging deadlocks

synctools

Synchronization tools for no_std

slock

An async mutex that never deadlocks

lockpool

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

thread-checked-lock

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

dir-lock

file-system-based mutex

borrow_mutex

Async Rust Mutex which does not require wrapping the target structure

shared-mutex

A RwLock that can be used with a Condvar

semalock

concurrently writing to files in a safe and efficient manner

rtfm-core

Core abstractions of the Real Time For the Masses framework

simplelock

abstractions for inter-process synchronization

redis-lock

distributed locking backed by Redis

one_at_a_time_please

For serialising calls to functions

microrust_inject

MicroRust Dependency Injection

lazy_mut

Alternative to LazyLock<Mutex<T>>

parking_lot_rt

Parking-lot fork for real-time applications

shared-lock

A lock that protects multiple objects at once

sync_2

A little crate providing a Rust implemented Mutex and RwLock

cooptex

Deadlock free Mutexes

linux-interprocess

Linux IPC, currently only supports mutexes

remutex

Recursive mutex, adapted from Rust's standard library

nix-ipc

Unix interprocess communication

embedded_mutex

A minimal, no_std, non-blocking mutex for embedded Rust

with_lock

Deadlock freedom

spinning

Mutexes and SIX locks implemented by spinning

putex

process mutex

scoped-mutex

An abstraction over closure-based mutexes

pcp-mutex

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

oncemutex

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

emitter_runtime

Runtime support for rs-event-emitter

process-sync

Synchronization primitives for multiprocess environments

try-mutex

Fast non-blocking mutex

deadlocker

Bringing builder pattern to defeat deadlocks

lock_cell

A custom locking cell type written in Rust

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

jthread

Deadlock-free Mutual Exclusion locks for Rust

rufutex

Ulrich Drepper's mutex using futex implementation in Rust

option-lock

mutex for Option values

simple-mutex

A mutex more efficient than std and simpler than parking_lot

scoped-mutex-traits

An abstraction over closure-based mutexes

atomic_sync

Atomic-based synchronization implementing traits in abs_sync

chainmap

mutability of intermediate maps

atomic_pincell

Threadsafe pinnable RefCell

priomutex

A mutex where waiting threads specify a priority

namedlock

Namespaces for named locks

distributed-lock-core

Core traits and types for distributed locks

tokio-lk

Futures-aware lock-by-id primitives

async-debug

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

sortlock

providing ordered locking

bobcat-host

Functions for interacting with the host with bobcat-sdk

read-write-api

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

pinned-mutex

Mutex wrappers with structural pinning

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

critical-section-lock-mut

Provide locks for mutable data using critical-section crate

mutex_logger

logger that usess mutex for thread safty

raliguard

Lazy rate limit semaphore implementation for your asynchronous code frequency execution

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

thread-owned-lock

Mutex which can only be unlocked by the owning thread

pinnable

A Mutex that can be pinned

dfmutex

Deadlock-free Mutex locks

gmtx

Mutex that grant exclusive access to a group of members

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

shared-type

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

padlock

Safely acquire RwLock/Mutex locks

lock_many

Retry-based locking multiple mutexes at once

qadapt-spin

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

mutex-watersheds

Mutex Watershed based off the original C++ implementation by Steffen Wolf and Constantin Pape

fut_rwlock

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

fremkit

broadcast log

static_leak

Leak references with static lifetimes from static Mutexes and RwLocks

hybrid-lock

A hybrid lock with optimistic locking

bobcat-sdk

codesize efficient Arbitrum Stylus SDK

key-mutex

Access mutexes by key

rtic-core

Core abstractions of the Real-Time Interrupt-driven Concurrency framework