Struct ArcAsyncMutex 

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

Asynchronous Mutex Wrapper

Provides an encapsulation of asynchronous mutex for protecting shared data in asynchronous environments. Supports safe access and modification of shared data across multiple asynchronous tasks.

Features

• Asynchronously acquires locks, does not 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::{ArcAsyncMutex, AsyncLock};
use std::sync::Arc;

let rt = tokio::runtime::Builder::new_current_thread()
    .enable_all()
    .build()
    .unwrap();
rt.block_on(async {
    let counter = ArcAsyncMutex::new(0);
    let counter = Arc::new(counter);

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

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

Author

Haixing Hu

Implementations

impl<T> ArcAsyncMutex<T>

pub fn new(data: T) -> Self

Creates a new asynchronous mutex lock

Arguments

• data - The data to be protected

Returns

Returns a new ArcAsyncMutex instance

Example

use qubit_lock::lock::ArcAsyncMutex;

let lock = ArcAsyncMutex::new(42);

Trait Implementations

impl<T> AsyncLock<T> for ArcAsyncMutex<T>

where T: Send,

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

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

Acquires the mutex and executes a read-only operation.

Arguments

• f - Closure receiving immutable access to the protected value.

Returns

A future resolving to the closure result.

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

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

Acquires the mutex and executes a mutable operation.

Arguments

• f - Closure receiving mutable access to the protected value.

Returns

A future resolving to the closure result.

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

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

Attempts to acquire the mutex for a read-only operation without waiting.

Arguments

• f - Closure receiving immutable access when the mutex is available.

Returns

Some(result) if the mutex was acquired, or None if it was busy.

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

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

Attempts to acquire the mutex for a mutable operation without waiting.

Arguments

• f - Closure receiving mutable access when the mutex is available.

Returns

Some(result) if the mutex was acquired, or None if it was busy.

impl<T> Clone for ArcAsyncMutex<T>

fn clone(&self) -> Self

Clones the asynchronous mutex

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

Returns

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

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

Performs copy-assignment from source.