Struct ArcStdMutex 

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

Synchronous Standard Mutex Wrapper

Provides an encapsulation of synchronous mutex using std::sync::Mutex for protecting shared data in synchronous environments. Supports safe access and modification of shared data across multiple threads.

Features

• Synchronously acquires locks, may block threads
• Supports trying to acquire locks (non-blocking)
• Thread-safe, supports multi-threaded sharing
• Automatic lock management through RAII ensures proper lock release

Usage Example

use qubit_lock::lock::{ArcStdMutex, Lock};

let counter = ArcStdMutex::new(0);

// Synchronously modify data
counter.write(|c| {
    *c += 1;
    println!("Counter: {}", *c);
});

// Try to acquire lock
if let Ok(value) = counter.try_read(|c| *c) {
    println!("Current value: {}", value);
}

Author

Haixing Hu

Implementations

impl<T> ArcStdMutex<T>

pub fn new(data: T) -> Self

Creates a new synchronous mutex lock

Arguments

• data - The data to be protected

Returns

Returns a new ArcStdMutex instance

Example

use qubit_lock::lock::ArcStdMutex;

let lock = ArcStdMutex::new(42);

Trait Implementations

impl<T> Clone for ArcStdMutex<T>

fn clone(&self) -> Self

Clones the synchronous mutex

Creates a new ArcStdMutex instance that shares the same underlying lock with the original instance. This allows multiple threads to hold references to the same lock simultaneously.

Returns

A new handle sharing the same underlying mutex and protected value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Lock<T> for ArcStdMutex<T>

fn read<R, F>(&self, f: F) -> R

where F: FnOnce(&T) -> R,

Acquires a read lock and executes an operation

For ArcStdMutex, this acquires the same exclusive lock as write operations, but provides immutable access to the data. This ensures thread safety while allowing read-only operations.

Arguments

• f - The closure to be executed while holding the read lock

Returns

Returns the result of executing the closure

Panics

Panics if the underlying standard mutex is poisoned.

Example

use qubit_lock::lock::{ArcStdMutex, Lock};

let counter = ArcStdMutex::new(42);

let value = counter.read(|c| *c);
println!("Current value: {}", value);

fn write<R, F>(&self, f: F) -> R

where F: FnOnce(&mut T) -> R,

Acquires a write lock and executes an operation

Synchronously acquires the exclusive lock, executes the provided closure with mutable access, and then automatically releases the lock. This is the recommended usage pattern for modifications.

Arguments

• f - The closure to be executed while holding the write lock

Returns

Returns the result of executing the closure

Panics

Panics if the underlying standard mutex is poisoned.

Example

use qubit_lock::lock::{ArcStdMutex, Lock};

let counter = ArcStdMutex::new(0);

let result = counter.write(|c| {
    *c += 1;
    *c
});

println!("Counter value: {}", result);

fn try_read<R, F>(&self, f: F) -> Result<R, TryLockError>

where F: FnOnce(&T) -> R,

Attempts to acquire a read lock without blocking

Attempts to immediately acquire the read lock. If the lock is unavailable, returns a detailed error. This is a non-blocking operation.

Arguments

• f - The closure to be executed while holding the read lock

Returns

• Ok(R) - If the lock was successfully acquired and the closure executed
• Err(TryLockError::WouldBlock) - If the lock is already held by another thread
• Err(TryLockError::Poisoned) - If the lock is poisoned

Example

use qubit_lock::lock::{ArcStdMutex, Lock};

let counter = ArcStdMutex::new(42);

if let Ok(value) = counter.try_read(|c| *c) {
    println!("Current value: {}", value);
} else {
    println!("Lock is unavailable");
}

fn try_write<R, F>(&self, f: F) -> Result<R, TryLockError>

where F: FnOnce(&mut T) -> R,

Attempts to acquire a write lock without blocking

Attempts to immediately acquire the write lock. If the lock is unavailable, returns a detailed error. This is a non-blocking operation.

Arguments

• f - The closure to be executed while holding the write lock

Returns

• Ok(R) - If the lock was successfully acquired and the closure executed
• Err(TryLockError::WouldBlock) - If the lock is already held by another thread
• Err(TryLockError::Poisoned) - If the lock is poisoned

Example

use qubit_lock::lock::{ArcStdMutex, Lock};

let counter = ArcStdMutex::new(0);

if let Ok(result) = counter.try_write(|c| {
    *c += 1;
    *c
}) {
    println!("New value: {}", result);
} else {
    println!("Lock is unavailable");
}