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

mea

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

maitake-sync

No-std async synchronization primitives from Maitake

futures-intrusive

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

guardian

owned mutex guards for refcounted mutexes

saa

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

bach

Discrete-event simulation environment for async workflows

mutex

An abstraction over closure-based mutexes

keepcalm

shared types for multi-threaded programs

piper

Async pipes, channels, mutexes, and more

mutex-traits

An abstraction over closure-based mutexes

mcslock

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

instance-copy-on-write

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

lockable

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

xutex

an extremely fast async mutex with alternative sync API

happylock

Free deadlock prevention

tracing-mutex

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

no_deadlocks

A Runtime Deadlock Debugger

rust_web_crawler

A short summary of what your crate does

wasm_safe_mutex

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

azalea

A framework for creating Minecraft bots

async-mutex

Async mutex

crossync

A fast concurrent programming suite for Rust

mintex

minimal mutex

wdk-mutex

An idiomatic Rust mutex type for Windows kernel driver development

fmutex

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

range-lock

Range lock for std::vec::Vec

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

rustix-futex-sync

Linux futex-based synchronization

wrapit

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

filelock

Cross-platform file locking library for Rust

tui_lib

Be the base of a Tui Operation

lfrlock

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

k-lock

A fast mutex for short critical sections

distributed-lock-mongo

MongoDB backend for distributed locks using atomic updates and TTL indexes

steppe

Follow the progress of a task easily

keyed-lock

A keyed lock for synchronization

async-rwlock

Async reader-writer lock

rlock

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

global_counter

Global, thread-safe counters

range-mutex

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

one-shot-mutex

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

cynosure

High performance data structures & primitives from beyond the Blackwall

orchestrator_lock

A Mutex whose access order is managed by a separate thread

sharded_mutex

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

synchronized-writer

A tiny implement for synchronously writing data

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

hermit-sync

Synchronization primitives for kernels

local_async_utils

single-threaded async programming

antidote

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

dportable

Portable interface for various utilities

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

lamlock

MCS-style flat-combining mutex with panic-awareness

distributed-lock-postgres

PostgreSQL backend for distributed locks using advisory locks

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)

easy_mutex

A cloneable mutex wrapper that simplifies everyday use

usync

fast, drop-in, synchronization primitives

distributed-lock-file

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

nospin

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

mbarc-map

Minimally-blocking, Atomic Reference Counted Map

unlock

Instrumented synchronization primitives helping you to unlock performance issues

rusturnate

A sync or async mutex, with or without timeouts

td_rthreadpool

thread wrapper for Rust

wasefire-sync

Portable non-blocking mutex

esp-sync

Synchronization primitives for Espressif devices

forrust_fire_tracing

Tracing integration for forrust_fire_tree

lock-hierarchy

Prevent dead locks by enforcing lock hierarchies

pi_stash

nimbusqueue

fifo collection

peace-lock

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

parking_lot_core

An advanced API for creating custom synchronization primitives

lazymut

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

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

syncrs

spinlock-based syncronization primitives for no_std enviroments

classic-sync

ReentrantLock, Semaphore and CyclicBarrier using Classic Linux Mutex systems

mutex_trait2

Generic mutex trait

armc

that facilitates Mutex access to variables

linux-interprocess

Linux IPC, currently only supports mutexes

atrilocks

collection of light weight async synchronization primitives based on atomics

mutex-trait

Foundational mutex trait and helpers

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

borrow_mutex

Async Rust Mutex which does not require wrapping the target structure

microrust_inject

MicroRust Dependency Injection

shared-lock

A lock that protects multiple objects at once

dir-lock

file-system-based mutex

semalock

concurrently writing to files in a safe and efficient manner

shared-mutex

A RwLock that can be used with a Condvar

simplelock

abstractions for inter-process synchronization

rtfm-core

Core abstractions of the Real Time For the Masses framework

one_at_a_time_please

For serialising calls to functions

redis-lock

distributed locking backed by Redis

lazy_mut

Alternative to LazyLock<Mutex<T>>

parking_lot_rt

Parking-lot fork for real-time applications

sync_2

A little crate providing a Rust implemented Mutex and RwLock

cooptex

Deadlock free Mutexes

remutex

Recursive mutex, adapted from Rust's standard library

embedded_mutex

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

with_lock

Deadlock freedom

putex

process mutex

spinning

Mutexes and SIX locks implemented by spinning

scoped-mutex

An abstraction over closure-based mutexes

rufutex

Ulrich Drepper's mutex using futex implementation in Rust

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

scoped-mutex-traits

An abstraction over closure-based mutexes

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

option-lock

mutex for Option values

simple-mutex

A mutex more efficient than std and simpler than parking_lot

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

distributed-lock-core

Core traits and types for distributed locks

namedlock

Namespaces for named 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

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

dfmutex

Deadlock-free Mutex locks

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

gmtx

Mutex that grant exclusive access to a group of members

nest-guard

working with nested guard-type APIs

shared-type

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

mutex-extra

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

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

rtic-core

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

key-mutex

Access mutexes by key

waitable

A synchronized (atomic) value container implementing the Mutex+Condvar pattern for efficient blocking waits

pairlock

A reader-writer lock with wait-free reads