结构体 OwnedRwLockWriteGuard

源代码

pub struct OwnedRwLockWriteGuard<T: ?Sized> { /* 私有字段 */ }

展开描述

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

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

实现§

源代码 §

impl<T: ?Sized> OwnedRwLockWriteGuard<T>

源代码

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

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

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

这是一个关联函数，需要以 OwnedRwLockWriteGuard::map(..) 的方式使用。如果使用方法，将与已锁定数据内容上同名的方法产生冲突。

§示例

use std::sync::Arc;
use tokio::sync::{RwLock, OwnedRwLockWriteGuard};

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

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

{
    let lock = Arc::clone(&lock);
    let mut mapped = OwnedRwLockWriteGuard::map(lock.write_owned().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, ) -> OwnedRwLockReadGuard<T, U>
where F: FnOnce(&T) -> &U,

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

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

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

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

§示例

use std::sync::Arc;
use tokio::sync::{RwLock, OwnedRwLockWriteGuard};

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

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

let guard = Arc::clone(&lock).write_owned().await;
let mapped = OwnedRwLockWriteGuard::downgrade_map(guard, |f| &f.0);
let foo = lock.read_owned().await;
assert_eq!(foo.0, *mapped);

源代码

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

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

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

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

§示例

use std::sync::Arc;
use tokio::sync::{RwLock, OwnedRwLockWriteGuard};

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

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

{
    let guard = Arc::clone(&lock).write_owned().await;
    let mut guard = OwnedRwLockWriteGuard::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<OwnedRwLockReadGuard<T, U>, Self>
where F: FnOnce(&T) -> Option<&U>,

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

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

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

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

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

§示例

use std::sync::Arc;
use tokio::sync::{RwLock, OwnedRwLockWriteGuard};

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

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

let guard = Arc::clone(&lock).write_owned().await;
let guard = OwnedRwLockWriteGuard::try_downgrade_map(guard, |f| Some(&f.0)).expect("should not fail");
let foo = lock.read_owned().await;
assert_eq!(foo.0, *guard);

源代码

pub fn into_mapped(this: Self) -> OwnedRwLockMappedWriteGuard<T>

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

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

源代码

pub fn downgrade(self) -> OwnedRwLockReadGuard<T>

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

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

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

§示例

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

let n = lock.clone().write_owned().await;

let cloned_lock = lock.clone();
let handle = tokio::spawn(async move {
    *cloned_lock.write_owned().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");

源代码

pub fn rwlock(this: &Self) -> &Arc<RwLock<T>>

返回对原始 Arc<RwLock> 的引用。

§示例

use std::sync::Arc;
use tokio::sync::{RwLock, OwnedRwLockWriteGuard};

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

let guard = lock.clone().write_owned().await;
assert!(Arc::ptr_eq(&lock, OwnedRwLockWriteGuard::rwlock(&guard)));