Struct ArcRwLock 

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

Parking-lot read-write lock wrapper.

Provides an Arc-wrapped parking_lot::RwLock for synchronous shared state. 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
• Does not use lock poisoning; panic while holding the lock does not make future acquisitions fail
• Implements Deref and AsRef to expose the underlying parking_lot::RwLock API when guard-based access is needed

Use Cases

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

Usage Example

use qubit_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::ArcRwLock;

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

Trait Implementations

impl<T> AsRef<RwLock<RawRwLock, T>> for ArcRwLock<T>

fn as_ref(&self) -> &RwLock<T>

Returns a reference to the underlying parking_lot read-write lock.

This is useful when callers need guard-based APIs such as RwLock::read or RwLock::write instead of the closure-based Lock methods.

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: Default> Default for ArcRwLock<T>

fn default() -> Self

Creates an Arc-wrapped parking_lot read-write lock containing T::default().

Returns

A new ArcRwLock protecting the default value for T.

impl<T> Deref for ArcRwLock<T>

fn deref(&self) -> &Self::Target

Dereferences this wrapper to the underlying parking_lot read-write lock.

When Lock is in scope, read and write with closure arguments still call the trait methods on this wrapper. Use explicit dereferencing or AsRef::as_ref when you want the native guard-based RwLock methods.

type Target = RwLock<RawRwLock, T>

The resulting type after dereferencing.

impl<T> From<T> for ArcRwLock<T>

fn from(value: T) -> Self

Creates an Arc-wrapped parking_lot read-write lock from a value.

Arguments

• value - The value to protect.

Returns

A new ArcRwLock protecting value.

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

Example

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

Example

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

Example

use qubit_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 unavailable

Example

use qubit_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");
}