结构体 RwLockWriteGuard

源代码

pub struct RwLockWriteGuard<'a, T: ?Sized> { /* 私有字段 */ }

展开描述

用于在 drop 时释放锁的独占写访问权的 RAII 结构。

此结构体由 RwLock 上的 write 方法创建。

实现§

源代码 §

impl<'a, T: ?Sized> RwLockWriteGuard<'a, T>

源代码

pub fn map<F, U: ?Sized>(this: Self, f: F) -> RwLockMappedWriteGuard<'a, U>
where F: FnOnce(&mut T) -> &mut U,

为锁定数据的组件创建一个新的 RwLockMappedWriteGuard。

此操作不会失败，因为传入的 RwLockWriteGuard 已经锁定了数据。

这是一个关联函数，需要用作 RwLockWriteGuard::map(..)。方法会与锁定数据内容上的同名方法冲突。

这是来自 parking_lot crate 的 RwLockWriteGuard::map 的异步版本。

§示例

use tokio::sync::{RwLock, RwLockWriteGuard};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Foo(u32);

let lock = RwLock::new(Foo(1));

{
    let mut mapped = RwLockWriteGuard::map(lock.write().await, |f| &mut f.0);
    *mapped = 2;
}

assert_eq!(Foo(2), *lock.read().await);

源代码

pub fn downgrade_map<F, U: ?Sized>(this: Self, f: F) -> RwLockReadGuard<'a, U>
where F: FnOnce(&T) -> &U,

为锁定数据的组件创建一个新的 RwLockReadGuard。

此操作不会失败，因为传入的 RwLockWriteGuard 已经锁定了数据。

这是一个关联函数，需要用作 RwLockWriteGuard::downgrade_map(..)。方法会与锁定数据内容上的同名方法冲突。

这等效于来自 parking_lot crate 的异步 RwLockWriteGuard::map 和 RwLockWriteGuard::downgrade 的组合。

在 f 内部，即使只获得了 &T，你仍然保留对数据的独占访问权。交出 &mut T 将导致内存不安全，因为你可以使用内部可变性。

§示例

use tokio::sync::{RwLock, RwLockWriteGuard};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Foo(u32);

let lock = RwLock::new(Foo(1));

let mapped = RwLockWriteGuard::downgrade_map(lock.write().await, |f| &f.0);
let foo = lock.read().await;
assert_eq!(foo.0, *mapped);

源代码

pub fn try_map<F, U: ?Sized>( this: Self, f: F, ) -> Result<RwLockMappedWriteGuard<'a, U>, Self>
where F: FnOnce(&mut T) -> Option<&mut U>,

尝试为已锁定数据的某个组件创建一个新的 RwLockMappedWriteGuard。如果闭包返回 None，则返回原始守卫。

此操作不会失败，因为传入的 RwLockWriteGuard 已经锁定了数据。

这是一个关联函数，需要用作 RwLockWriteGuard::try_map(...)。方法会与锁定数据内容上的同名方法冲突。

这是来自 parking_lot crate 的 RwLockWriteGuard::try_map 的异步版本。

§示例

use tokio::sync::{RwLock, RwLockWriteGuard};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Foo(u32);

let lock = RwLock::new(Foo(1));

{
    let guard = lock.write().await;
    let mut guard = RwLockWriteGuard::try_map(guard, |f| Some(&mut f.0)).expect("should not fail");
    *guard = 2;
}

assert_eq!(Foo(2), *lock.read().await);

源代码

pub fn try_downgrade_map<F, U: ?Sized>( this: Self, f: F, ) -> Result<RwLockReadGuard<'a, U>, Self>
where F: FnOnce(&T) -> Option<&U>,

尝试为锁定数据的组件创建一个新的 RwLockReadGuard。如果闭包返回 None，则返回原始 guard。

此操作不会失败，因为传入的 RwLockWriteGuard 已经锁定了数据。

这是一个关联函数，需要用作 RwLockWriteGuard::try_downgrade_map(...)。方法会与锁定数据内容上的同名方法冲突。

这等效于来自 parking_lot crate 的异步 RwLockWriteGuard::try_map 和 RwLockWriteGuard::downgrade 的组合。

在 f 内部，即使只获得了 &T，你仍然保留对数据的独占访问权。交出 &mut T 将导致内存不安全，因为你可以使用内部可变性。

如果此函数返回 Err(...)，则锁既不会被解锁，也不会被降级。

§示例

use tokio::sync::{RwLock, RwLockWriteGuard};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Foo(u32);

let lock = RwLock::new(Foo(1));

let guard = RwLockWriteGuard::try_downgrade_map(lock.write().await, |f| Some(&f.0)).expect("should not fail");
let foo = lock.read().await;
assert_eq!(foo.0, *guard);

源代码

pub fn into_mapped(this: Self) -> RwLockMappedWriteGuard<'a, T>

将此 RwLockWriteGuard 转换为 RwLockMappedWriteGuard。此方法可用于将非映射 guard 存储在期望映射 guard 的结构体字段中。

这等效于调用 RwLockWriteGuard::map(guard, |me| me)。

源代码

pub fn downgrade(self) -> RwLockReadGuard<'a, T>

原子地将写锁降级为读锁，期间不允许任何写入者获取锁的独占访问权。

注意：这不一定会允许任何额外的读取者获取锁，因为 RwLock 是公平的，并且可能有写入者排在下一位。

返回一个 RAII 守卫，当它被 drop 时会释放此 RwLock 的读访问权。

§示例

let lock = Arc::new(RwLock::new(1));

let n = lock.write().await;

let cloned_lock = lock.clone();
let handle = tokio::spawn(async move {
    *cloned_lock.write().await = 2;
});

let n = n.downgrade();
assert_eq!(*n, 1, "downgrade is atomic");

drop(n);
handle.await.unwrap();
assert_eq!(*lock.read().await, 2, "second writer obtained write lock");