Struct ArcRwLock 

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

Synchronous Read-Write Lock Wrapper

Provides an encapsulation of synchronous 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
• Synchronously acquires locks, may 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::ArcRwLock;
use std::sync::Arc;

let data = ArcRwLock::new(String::from("Hello"));
let data = Arc::new(data);

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

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

Author

Haixing Hu

Implementations

impl<T> ArcRwLock<T>

pub fn new(data: T) -> Self

Creates a new synchronous read-write lock

Arguments

• data - The data to be protected

Returns

Returns a new ArcRwLock instance

Example

use prism3_concurrent::ArcRwLock;

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

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

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

Acquires the read lock and executes an operation

Synchronously 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::ArcRwLock;

let data = ArcRwLock::new(vec![1, 2, 3]);

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

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

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

Acquires the write lock and executes an operation

Synchronously 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::ArcRwLock;

let data = ArcRwLock::new(vec![1, 2, 3]);

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

Trait Implementations

impl<T> Clone for ArcRwLock<T>

fn clone(&self) -> Self

Clones the synchronous read-write lock

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

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

Performs copy-assignment from source.