Struct lock_api::RwLockReadGuard

#[must_use]
pub struct RwLockReadGuard<'a, R: RawRwLock + 'a, T: ?Sized + 'a> { /* fields omitted */ }

RAII structure used to release the shared read access of a lock when dropped.

Methods

impl<'a, R: RawRwLock + 'a, T: ?Sized + 'a> RwLockReadGuard<'a, R, T>

pub fn rwlock(s: &Self) -> &'a RwLock<R, T>

Returns a reference to the original reader-writer lock object.

pub fn map<U: ?Sized, F>(s: Self, f: F) -> MappedRwLockReadGuard<'a, R, U> where     F: FnOnce(&T) -> &U,

Make a new MappedRwLockReadGuard for a component of the locked data.

This operation cannot fail as the RwLockReadGuard passed in already locked the data.

This is an associated function that needs to be used as RwLockReadGuard::map(...). A method would interfere with methods of the same name on the contents of the locked data.

pub fn unlocked<F, U>(s: &mut Self, f: F) -> U where     F: FnOnce() -> U,

Temporarily unlocks the RwLock to execute the given function.

The RwLock is unlocked a fair unlock protocol.

This is safe because &mut guarantees that there exist no other references to the data protected by the RwLock.

impl<'a, R: RawRwLockFair + 'a, T: ?Sized + 'a> RwLockReadGuard<'a, R, T>

pub fn unlock_fair(s: Self)

Unlocks the RwLock using a fair unlock protocol.

By default, RwLock is unfair and allow the current thread to re-lock the RwLock before another has the chance to acquire the lock, even if that thread has been blocked on the RwLock for a long time. This is the default because it allows much higher throughput as it avoids forcing a context switch on every RwLock unlock. This can result in one thread acquiring a RwLock many more times than other threads.

However in some cases it can be beneficial to ensure fairness by forcing the lock to pass on to a waiting thread if there is one. This is done by using this method instead of dropping the RwLockReadGuard normally.

pub fn unlocked_fair<F, U>(s: &mut Self, f: F) -> U where     F: FnOnce() -> U,

Temporarily unlocks the RwLock to execute the given function.

The RwLock is unlocked a fair unlock protocol.

This is safe because &mut guarantees that there exist no other references to the data protected by the RwLock.

pub fn bump(s: &mut Self)

Temporarily yields the RwLock to a waiting thread if there is one.

This method is functionally equivalent to calling unlock_fair followed by read, however it can be much more efficient in the case where there are no waiting threads.

Trait Implementations

impl<'a, R: RawRwLock + 'a, T: ?Sized + Sync + 'a> Sync for RwLockReadGuard<'a, R, T>

impl<'a, R: RawRwLock + 'a, T: ?Sized + 'a> Deref for RwLockReadGuard<'a, R, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<'a, R: RawRwLock + 'a, T: ?Sized + 'a> Drop for RwLockReadGuard<'a, R, T>

fn drop(&mut self)

Executes the destructor for this type.