Struct Mutex

pub struct Mutex<T> { /* private fields */ }

Wrapper around a std::sync::Mutex which uses a thread local variable in order to check for lock hierarchy violations in debug builds.

See the crate level documentation for more general information.

use lock_hierarchy::Mutex;

let mutex_a = Mutex::new(()); // Level 0
let mutex_b = Mutex::with_level((), 0); // also level 0
// Fine, first mutex in thread
let _guard_a = mutex_a.lock().unwrap();
// Would panic, lock hierarchy violation
// let _guard_b = mutex_b.lock().unwrap();

Implementations

impl<T> Mutex<T>

pub fn new(t: T) -> Self

Creates lock with level 0. Use this constructor if you want to get an error in debug builds every time you acquire another lock while holding this one.

pub fn with_level(t: T, level: u32) -> Self

Creates a lock and assigns it a level in the lock hierarchy. Higher levels must be acquired first if locks are to be held simultaneously. This way we can ensure locks are always acquired in the same order. This prevents deadlocks.

pub fn lock(&self) -> LockResult<MutexGuard<'_, T>>

See std::sync::Mutex::lock

pub fn get_mut(&mut self) -> LockResult<&mut T>

See std::sync::Mutex::get_mut

pub fn into_inner(self) -> LockResult<T>

See std::sync::Mutex::into_inner

Trait Implementations

impl<T: Debug> Debug for Mutex<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default> Default for Mutex<T>

fn default() -> Mutex<T>

Returns the “default value” for a type.

impl<T> From<T> for Mutex<T>

fn from(value: T) -> Self

Creates a new mutex in an unlocked state ready for use. This is equivalent to Mutex::new.