Struct ArcAsyncRwLock 

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

Asynchronous Read-Write Lock Wrapper

Provides an encapsulation of asynchronous read-write lock, supporting multiple read operations or a single write operation. Read operations can execute concurrently, while write operations have exclusive access.

Features

• Supports multiple concurrent read operations
• Write operations have exclusive access, mutually exclusive with read operations
• Asynchronously acquires locks, does not block threads
• Thread-safe, supports multi-threaded sharing
• Automatic lock management through RAII ensures proper lock release

Use Cases

Suitable for read-heavy scenarios such as caching, configuration management, etc.

Usage Example

use prism3_concurrent::ArcAsyncRwLock;
use std::sync::Arc;

#[tokio::main]
async fn main() {
    let data = ArcAsyncRwLock::new(String::from("Hello"));
    let data = Arc::new(data);

    // Multiple read operations can execute concurrently
    data.with_read_lock(|s| {
        println!("Read: {}", s);
    }).await;

    // Write operations have exclusive access
    data.with_write_lock(|s| {
        s.push_str(" World!");
        println!("Write: {}", s);
    }).await;
}

Author

Haixing Hu

Implementations

impl<T> ArcAsyncRwLock<T>

pub fn new(data: T) -> Self

Creates a new asynchronous read-write lock

Arguments

• data - The data to be protected

Returns

Returns a new ArcAsyncRwLock instance

Example

use prism3_concurrent::ArcAsyncRwLock;

let rw_lock = ArcAsyncRwLock::new(vec![1, 2, 3]);

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

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

Acquires the read lock and executes an operation

Asynchronously acquires the read lock, executes the provided closure, and then automatically releases the lock. Multiple read operations can execute concurrently.

Arguments

• f - The closure to be executed while holding the read lock, can only read data

Returns

Returns the result of executing the closure

Example

use prism3_concurrent::ArcAsyncRwLock;

#[tokio::main]
async fn main() {
    let data = ArcAsyncRwLock::new(vec![1, 2, 3]);

    let length = data.with_read_lock(|v| v.len()).await;
    println!("Vector length: {}", length);
}

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

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

Acquires the write lock and executes an operation

Asynchronously acquires the write lock, executes the provided closure, and then automatically releases the lock. Write operations have exclusive access, mutually exclusive with read operations.

Arguments

• f - The closure to be executed while holding the write lock, can modify data

Returns

Returns the result of executing the closure

Example

use prism3_concurrent::ArcAsyncRwLock;

#[tokio::main]
async fn main() {
    let data = ArcAsyncRwLock::new(vec![1, 2, 3]);

    data.with_write_lock(|v| {
        v.push(4);
        println!("Added element, new length: {}", v.len());
    }).await;
}

Trait Implementations

impl<T> Clone for ArcAsyncRwLock<T>

fn clone(&self) -> Self

Clones the asynchronous read-write lock

Creates a new ArcAsyncRwLock 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.