Struct RwLock 

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

A tracked read-write lock that automatically records contention metrics and integrates with deadlock detection.

This is a drop-in replacement for tokio::sync::RwLock with additional observability features. It tracks read and write operations separately.

Example

use async_inspect::sync::RwLock;

#[tokio::main]
async fn main() {
    let lock = RwLock::new(vec![1, 2, 3], "shared_data");

    // Multiple readers can access simultaneously
    let lock = std::sync::Arc::new(lock);
    let mut handles = vec![];

    for i in 0..5 {
        let l = lock.clone();
        handles.push(tokio::spawn(async move {
            let guard = l.read().await;
            println!("Reader {}: {:?}", i, *guard);
        }));
    }

    // Writer has exclusive access
    {
        let mut guard = lock.write().await;
        guard.push(4);
    }

    for h in handles {
        h.await.unwrap();
    }

    // Check contention metrics
    let (read_metrics, write_metrics) = lock.metrics();
    println!("Read acquisitions: {}", read_metrics.acquisitions);
    println!("Write acquisitions: {}", write_metrics.acquisitions);
}

Implementations

impl<T> RwLock<T>

pub fn new(value: T, name: impl Into<String>) -> Self

Create a new tracked RwLock with a name for identification.

Arguments

• value - The initial value to protect
• name - A descriptive name for debugging and metrics

Example

use async_inspect::sync::RwLock;
use std::collections::HashMap;

let lock = RwLock::new(HashMap::<String, i32>::new(), "user_cache");

pub async fn read(&self) -> RwLockReadGuard<'_, T>

Acquire a read lock, blocking until it’s available.

Multiple readers can hold the lock simultaneously, but writers must wait for all readers to release.

Example

use async_inspect::sync::RwLock;

let lock = RwLock::new(42, "my_value");
let guard = lock.read().await;
println!("Value: {}", *guard);

pub async fn write(&self) -> RwLockWriteGuard<'_, T>

Acquire a write lock, blocking until it’s available.

Writers have exclusive access - no other readers or writers can hold the lock simultaneously.

Example

use async_inspect::sync::RwLock;

let lock = RwLock::new(42, "my_value");
let mut guard = lock.write().await;
*guard = 100;

pub fn try_read(&self) -> Option<RwLockReadGuard<'_, T>>

Try to acquire a read lock immediately.

Returns None if a writer is holding the lock.

pub fn try_write(&self) -> Option<RwLockWriteGuard<'_, T>>

Try to acquire a write lock immediately.

Returns None if any readers or writers are holding the lock.

pub fn metrics(&self) -> (LockMetrics, LockMetrics)

Get the current contention metrics for this RwLock.

Returns a tuple of (read_metrics, write_metrics).

Example

use async_inspect::sync::RwLock;

let lock = RwLock::new(42, "my_value");
// ... some operations ...
let (read_metrics, write_metrics) = lock.metrics();
println!("Read acquisitions: {}", read_metrics.acquisitions);
println!("Write acquisitions: {}", write_metrics.acquisitions);

pub fn read_metrics(&self) -> LockMetrics

Get only the read metrics.

pub fn write_metrics(&self) -> LockMetrics

Get only the write metrics.

pub fn reset_metrics(&self)

Reset all contention metrics.

pub fn name(&self) -> &str

Get the name of this RwLock.

pub fn resource_id(&self) -> ResourceId

Get the resource ID for deadlock detection.

pub fn into_inner(self) -> T

Consume the RwLock and return the inner value.

pub fn get_mut(&mut self) -> &mut T

Get a mutable reference to the inner value without locking.

This is safe because we have exclusive access via &mut self.

Trait Implementations

impl<T: Debug> Debug for RwLock<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.