Crate lockpool

This library is not maintained anymore. Please use the lockable crate instead.

It offers a LockPool data structure with pretty much the same functionality that was offered by this crate. There is an example for a lock pool in the README.

This library offers a pool of locks where individual locks can be locked/unlocked by key. It initially considers all keys as “unlocked”, but they can be locked and if a second thread tries to acquire a lock for the same key, they will have to wait.

use lockpool::{LockPool, SyncLockPool};

let pool = SyncLockPool::new();
let guard1 = pool.lock(4)?;
let guard2 = pool.lock(5)?;

// This next line would cause a deadlock or panic because `4` is already locked on this thread
// let guard3 = pool.lock(4)?;

// After dropping the corresponding guard, we can lock it again
std::mem::drop(guard1);
let guard3 = pool.lock(4)?;

You can use an arbitrary type to index locks by, as long as that type implements PartialEq + Eq + Hash + Clone + Debug.

use lockpool::{LockPool, SyncLockPool};

#[derive(PartialEq, Eq, Hash, Clone, Debug)]
struct CustomLockKey(u32);

let pool = SyncLockPool::new();
let guard = pool.lock(CustomLockKey(4))?;

Under the hood, a LockPool is a HashMap of Mutexes, with some logic making sure there aren’t any race conditions when accessing the hash map.

If the tokio feature is enabled, then this crate also offers [TokioLockPool] which allows locks to be held across await points.

Structs

PoisonError

A type of error which can be returned whenever a lock is acquired.

Enums

Never

A type that can never be instantiated. This can be used in a Result<T, Never> to indicate that an operation cannot return an error.

TryLockError

Errors that can be thrown by LockPool::try_lock.

UnpoisonError

Errors that can be thrown by LockPool::unpoison.

Traits

Guard

A RAII implementation of a scoped lock for locks from a [LockPool]. When this instance is dropped (falls out of scope), the lock will be unlocked.

InfallibleUnwrap

Extension trait for Result<T, Never> that adds infallible_unwrap(), an infallible version of unwrap().

LockPool

A pool of locks where individual locks can be locked/unlocked by key. It initially considers all keys as “unlocked”, but they can be locked and if a second thread tries to acquire a lock for the same key, they will have to wait.

Type Definitions

SyncLockPool

SyncLockPool is an implementation of [LockPool] (see [LockPool] for API details) that is based on std::sync::Mutex and can be used in synchronous code. This implementation can also be used in async code and will be a little faster than [TokioLockPool], but its locks cannot be held across await points if the corresponding async task is sent across threads.