Struct tokio::sync::OwnedRwLockWriteGuard [−][src]
pub struct OwnedRwLockWriteGuard<T: ?Sized> { /* fields omitted */ }
sync
only.Expand description
Owned RAII structure used to release the exclusive write access of a lock when dropped.
This structure is created by the write_owned
method
on RwLock
.
Implementations
Make a new OwnedRwLockMappedWriteGuard
for a component of the locked
data.
This operation cannot fail as the OwnedRwLockWriteGuard
passed in
already locked the data.
This is an associated function that needs to be used as
OwnedRwLockWriteGuard::map(..)
. A method would interfere with methods
of the same name on the contents of the locked data.
Examples
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);
Attempts to make a new OwnedRwLockMappedWriteGuard
for a component
of the locked data. The original guard is returned if the closure
returns None
.
This operation cannot fail as the OwnedRwLockWriteGuard
passed in
already locked the data.
This is an associated function that needs to be
used as OwnedRwLockWriteGuard::try_map(...)
. A method would interfere
with methods of the same name on the contents of the locked data.
Examples
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);
Converts this OwnedRwLockWriteGuard
into an
OwnedRwLockMappedWriteGuard
. This method can be used to store a
non-mapped guard in a struct field that expects a mapped guard.
This is equivalent to calling OwnedRwLockWriteGuard::map(guard, |me| me)
.
Atomically downgrades a write lock into a read lock without allowing any writers to take exclusive access of the lock in the meantime.
Note: This won’t necessarily allow any additional readers to acquire
locks, since RwLock
is fair and it is possible that a writer is next
in line.
Returns an RAII guard which will drop this read access of the RwLock
when dropped.
Examples
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");
Trait Implementations
Auto Trait Implementations
impl<T> !RefUnwindSafe for OwnedRwLockWriteGuard<T>
impl<T: ?Sized> Unpin for OwnedRwLockWriteGuard<T> where
T: Unpin,
impl<T> !UnwindSafe for OwnedRwLockWriteGuard<T>