Struct Mutex 

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

A wrapper around a mutex that tracks lock operations for deadlock detection

The Mutex provides the same interface as a standard mutex but adds deadlock detection by tracking lock acquisition and release operations. It’s a drop-in replacement for std::sync::Mutex that enables deadlock detection.

Example

use deloxide::Mutex;
use std::sync::Arc;
use std::thread;

// Initialize detectors (not shown here)

// Create a tracked mutex
let mutex = Arc::new(Mutex::new(42));
let mutex_clone = Arc::clone(&mutex);

// Use it just like a regular mutex
thread::spawn(move || {
    let mut data = mutex.lock();
    *data += 1;
});

// In another thread
let mut data = mutex_clone.lock();
*data += 10;

Implementations

impl<T> Mutex<T>

pub fn new(value: T) -> Self

Create a new Mutex with an automatically assigned ID

Arguments

• value - The initial value to store in the mutex

Returns

A new Mutex containing the provided value

Example

use deloxide::Mutex;

let mutex = Mutex::new(42);

pub fn id(&self) -> LockId

Get the ID of this mutex

Returns

The unique identifier assigned to this mutex

pub fn creator_thread_id(&self) -> ThreadId

Get the ID of the thread that created this mutex

Returns

The thread ID of the creator thread

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

Acquire the lock, blocking if necessary

Uses atomic deadlock detection to prevent race conditions.

Uses the Optimistic Fast Path: attempts to acquire the lock cheaply first. Only interacts with the global deadlock detector if the lock is contented.

Example

use deloxide::Mutex;

let mutex = Mutex::new(42);
{
    let guard = mutex.lock();
    assert_eq!(*guard, 42);
} // lock is automatically released when guard goes out of scope

pub fn try_lock(&self) -> Option<MutexGuard<'_, T>>

Try to acquire the lock without blocking

Returns Some(guard) if successful, None if the lock is held.

Example

use deloxide::Mutex;

let mutex = Mutex::new(42);

// Non-blocking attempt to acquire the lock
if let Some(guard) = mutex.try_lock() {
    // Lock was acquired
    assert_eq!(*guard, 42);
} else {
    // Lock was already held by another thread
    println!("Lock already held by another thread");
}

pub fn into_inner(self) -> T

where T: Sized,

Consumes this mutex, returning the underlying data

Example

use deloxide::Mutex;

let mutex = Mutex::new(42);
let value = mutex.into_inner();
assert_eq!(value, 42);

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

Returns a mutable reference to the underlying data

Since this call borrows the Mutex mutably, no actual locking needs to take place – the mutable borrow statically guarantees no locks exist.

Example

use deloxide::Mutex;

let mut mutex = Mutex::new(0);
*mutex.get_mut() = 10;
assert_eq!(*mutex.lock(), 10);

Trait Implementations

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

fn default() -> Mutex<T>

Creates a Mutex<T>, with the Default value for T

impl<T> Drop for Mutex<T>

fn drop(&mut self)

Executes the destructor for this type.

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

fn from(t: T) -> Self

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