-
parking_lot
More compact and efficient implementations of the standard synchronization primitives
-
spin
Spin-based synchronization primitives
-
async-lock
Async synchronization primitives
-
atomic_refcell
Threadsafe RefCell
-
maitake-sync
No-std async synchronization primitives from Maitake
-
starshard
A blazing-fast sharded concurrent HashMap using hashbrown and RwLock, with lazy shards, atomic length cache, async support, conditional operations, batch operations, TTL/metrics/transactions
-
lock_api
Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.
-
seqlock
A reader-writer lock that provides extremely fast read access without starving writers
-
readlock-tokio
A weird alternative to Arc<RwLock<T>>, using tokio's RwLock
-
readlock
A weird alternative to Arc<RwLock<T>>
-
happylock
Free deadlock prevention
-
qubit-lock
Lock utilities library providing synchronous, asynchronous, and monitor-based locking primitives
-
tracing-mutex
Ensure deadlock-free mutexes by allocating in order, or else
-
no_deadlocks
A Runtime Deadlock Debugger
-
nym-cache
Helper functions around a RwLock for writing to local cache of items
-
moire
Runtime graph instrumentation for Tokio-based Rust systems
-
etchdb
A fast, embedded database for Rust. Minimal dependencies. No C code. No build scripts.
-
rustix-futex-sync
Linux futex-based synchronization
-
warcrwlock
in Rust that provides an attribute macro for structs and traits. Rewrite code using under the hood asynchronous reference (Arc) and asynchronous writing and read(RWlock) control elements.
-
config_rw
配置文件读取与写入
-
dportable
Portable interface for various utilities
-
stinger-rwlock-watch
An RwLock with a tokio::watch channel that is notified when releasing the write lock. Also, a readOnly lock.
-
generic_cache
Easy to use object caching based on defined TTL
-
cowboy
Safe & convenient container for quick prototyping
-
cerememory-store-working
Cerememory working store implementation
-
intrusivelock
Intrusive locks for Rust — locks that live inside the memory region they protect
-
mappedbptree
Memory maped (mmap) B+ tree implementation in Rust
-
rlock
Redis-backed lock library providing both async and sync Mutex, RwLock, and others
-
rs-bean
A lightweight Rust library for bean management
-
async-rwlock
Async reader-writer lock
-
snaplock
RwLock with lock-free Reads and sequential Writes
-
ruspiro-lock
Providing Spinlock, Semaphore and mutual exclusive data access for cross core usage on Raspberry Pi
-
active_standby
A concurrency primitive for high concurrency reads
-
xiaoyong-value
Collection of sharing state primitives for async contexts (both Sync and !Sync)
-
lockbell
An RwLock that rings back when contention clears
-
advisory-lock
A cross-platform advisory file lock
-
prism3-concurrent
Concurrent utilities library providing thread pools, task scheduling, synchronization primitives and other concurrent programming tools
-
aoko
extension library
-
usync
fast, drop-in, synchronization primitives
-
lock-hierarchy
Prevent dead locks by enforcing lock hierarchies
-
ext
extension library
-
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
-
antidote
Poison-free versions of the standard library Mutex and RwLock types
-
logging-subscriber
logging subscriber which can be silenced
-
unlock
Instrumented synchronization primitives helping you to unlock performance issues
-
bound
Wrap lock guards and other structs along with the locks or other data they are derived by shared reference from, in a struct you can pass around and store anywhere
-
facet-maybe-mut
abstract away lock primitives in facet
-
pflock
A phase-fair reader-writer lock that reduces worst-case blocking for readers. Especially useful for multiprocessor real-time systems.
-
revolt-coalesced
Revolt Backend: Coalescion service
-
vlock
A fast and scalable multi-version shared state lock with wait-free read access
-
cachedb
In memory Key/Value store that stores RwLock<Value> which expire in LRU order when unused
-
microkv
a minimal and persistent key-value store designed with security in mind
-
tspawn
A thread-safe wrapper around Arc<RwLock<T>> with convenient cloning semantics and async task spawning macros
-
shared-mutex
A RwLock that can be used with a Condvar
-
order-book
A price-priority order book implementation with support for market depth aggregation and thread-safe operations
-
or_poisoned
Unwrap std lock guards in a semantic way
-
one_at_a_time_please
For serialising calls to functions
-
parking_lot_rt
Parking-lot fork for real-time applications
-
anylock
Polymorphic Locks
-
wired_handler
Wired's handler library
-
sync_2
A little crate providing a Rust implemented Mutex and RwLock
-
spinning
Mutexes and SIX locks implemented by spinning
-
syncrs
spinlock-based syncronization primitives for no_std enviroments
-
fobserver
A lightweight and straightforward HTTP server library written in Rust
-
no-std-async
Async synchronization primitives for #[no_std] rust
-
cachelito-core
Core functionality for cachelito - global cache with LRU/FIFO/LFU/ARC/Random eviction policies
-
rust-debugging-locks
debugging locks in Rust
-
rapidsync
Rapid & threadsafe embedded data stores
-
atomic_sync
Atomic-based synchronization implementing traits in
abs_sync -
async_object
Async Object wrapper
-
sortlock
providing ordered locking
-
async-debug
Debug structs and enums containing values that require an async call to render
-
statia
A Universal and Lightweight, Zero dependency Rust state management library
-
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
-
wrrm
Write-rarely-read-many wrapper
-
simple-rw-global
GlobalContainer based on std::sync::RwLock
-
sublock
Variants of RwLock/RefCell that support sublocks, opened for reading if the main
RwLockis opened for reading, opened for writing if the mainRwLockis opened for writing -
fuser-async
Build FUSE filesystems where the system calls are directed to async functions. With an example S3 implementation.
-
nest-guard
working with nested guard-type APIs
-
qadapt-spin
Synchronization primitives based on spinning. They may contain data, are usable without
std, and static initializers are available -
padlock
Safely acquire RwLock/Mutex locks
-
spin-seq
Fork of the
seqlockcrate that can be used on bare metal -
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
-
hybrid-lock
A hybrid lock with optimistic locking
-
bellande_rwlock
A custom Read-Write Lock implementation developed by the Bellande Architecture Mechanism Research Innovation Center. Offers tools and utilities for concurrent read and write access to shared data
-
hashcons-arena
hash-consing arena
-
immutable_string
Immutable Single Instance Strings for Rust
-
rutin_dashmap
Blazing fast concurrent HashMap for Rust
-
pairlock
A reader-writer lock with wait-free reads
-
iter-tee
Make several clones of an iterator
-
atomic_refcell_try
Threadsafe RefCell
-
key-mutex
Access mutexes by key
-
qrwlock
Fair queued read-write lock
-
rw_lease
Fast Reader-Writer lock with reader draining support. Based on a single (parameterisable) atomic usize.
Try searching with DuckDuckGo.