Struct ArcMutex 

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

Synchronous Mutex Wrapper (Parking Lot)

Provides an encapsulation of synchronous mutex using parking_lot::Mutex for protecting shared data in synchronous environments. Supports safe access and modification of shared data across multiple threads. Compared to std::sync::Mutex, parking_lot::Mutex provides better performance and more ergonomic API.

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
• Better performance compared to std::sync::Mutex
• More ergonomic API with no unwrap() calls

Usage Example

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

let counter = ArcMutex::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> ArcMutex<T>

pub fn new(data: T) -> ArcMutex<T>

Creates a new synchronous mutex lock

Arguments

• data - The data to be protected

Returns

Returns a new ArcMutex instance

Example

use qubit_lock::lock::ArcMutex;

let lock = ArcMutex::new(42);

Examples found in repository

examples/double_checked_lock_executor_demo.rs (line 41)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create shared state
    let running = Arc::new(AtomicBool::new(false));
    let data = ArcMutex::new(42);

    println!(
        "Initial state: running = {}",
        running.load(Ordering::Acquire)
    );
    println!("Initial data: {}", data.read(|d| *d));

    let executor = DoubleCheckedLockExecutor::builder()
        .on(data.clone())
        .when({
            let running = running.clone();
            move || running.load(Ordering::Acquire)
        })
        .build();

    // Try to execute when service is not running (should fail)
    let result = executor
        .call_with(|value: &mut i32| {
            *value += 1;
            Ok::<_, ServiceError>(*value)
        })
        .get_result();

    if result.is_success() {
        println!("Unexpected success: {}", result.unwrap());
    } else {
        println!("Expected failure: Condition not met.");
    }

    // Start the service
    running.store(true, Ordering::Release);
    println!(
        "Service started: running = {}",
        running.load(Ordering::Acquire)
    );

    // Now execute should succeed
    let result = executor
        .call_with(|value: &mut i32| {
            *value += 1;
            Ok::<_, ServiceError>(*value)
        })
        .get_result();

    if result.is_success() {
        println!("Success: new value = {}", result.unwrap());
    } else {
        println!("Unexpected failure: {:?}", result);
    }

    // Verify the data was updated
    println!("Final data: {}", data.read(|d| *d));

    // Stop the service
    running.store(false, Ordering::Release);
    println!(
        "Service stopped: running = {}",
        running.load(Ordering::Acquire)
    );

    // Try to execute when service is stopped (should fail)
    let result = executor
        .call_with(|value: &mut i32| {
            *value += 1;
            Ok::<_, ServiceError>(*value)
        })
        .get_result();

    if result.is_success() {
        println!("Unexpected success: {}", result.unwrap());
    } else {
        println!("Expected failure: Condition not met.");
    }

    Ok(())
}

Trait Implementations

impl<T> Clone for ArcMutex<T>

fn clone(&self) -> ArcMutex<T>

Clones the synchronous mutex

Creates a new ArcMutex 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 ArcMutex<T>

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

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

Acquires a read lock and executes an operation

For ArcMutex, 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

Example

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

let counter = ArcMutex::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

Example

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

let counter = ArcMutex::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

Example

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

let counter = ArcMutex::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

Example

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

let counter = ArcMutex::new(0);

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