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 prism3_concurrent::ArcAsyncMutex;
use std::sync::Arc;

#[tokio::main]
async fn main() {
    let counter = ArcAsyncMutex::new(0);
    let counter = Arc::new(counter);

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

    // Try to acquire lock
    if let Some(value) = counter.try_with_lock(|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 prism3_concurrent::ArcAsyncMutex;

let lock = ArcAsyncMutex::new(42);

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

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

Acquires the lock and executes an operation

Asynchronously acquires the lock, executes the provided closure, and then automatically releases the lock. This is the recommended usage pattern as it ensures proper lock release.

Arguments

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

Returns

Returns the result of executing the closure

Example

use prism3_concurrent::ArcAsyncMutex;

#[tokio::main]
async fn main() {
    let counter = ArcAsyncMutex::new(0);

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

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

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

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

Attempts to acquire the lock

Attempts to immediately acquire the lock. If the lock is already held by another task, returns None. This is a non-blocking operation.

Arguments

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

Returns

• Some(R) - If the lock was successfully acquired and the closure executed
• None - If the lock is already held by another task

Example

use prism3_concurrent::ArcAsyncMutex;

let counter = ArcAsyncMutex::new(0);

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

Trait Implementations

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.

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

Performs copy-assignment from source.