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 qubit_lock::lock::{ArcRwLock, Lock};

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

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

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

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 qubit_lock::lock::ArcRwLock;

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

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.

Returns

A new handle sharing the same underlying read-write lock and protected value.

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

Performs copy-assignment from source.

impl<T> Lock<T> for ArcRwLock<T>

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

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

Acquires a 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, providing better performance for read-heavy workloads.

Arguments

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

Returns

Returns the result of executing the closure

Panics

Panics if the underlying standard read-write lock is poisoned.

Example

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

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

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

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 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

Panics

Panics if the underlying standard read-write lock is poisoned.

Example

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

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

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

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 currently held in write mode
• Err(TryLockError::Poisoned) - If the lock is poisoned

Example

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

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

if let Ok(length) = data.try_read(|v| v.len()) {
    println!("Vector length: {}", length);
} 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 currently held by another thread
• Err(TryLockError::Poisoned) - If the lock is poisoned

Example

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

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

if let Ok(new_length) = data.try_write(|v| {
    v.push(4);
    v.len()
}) {
    println!("New length: {}", new_length);
} else {
    println!("Lock is unavailable");
}