Struct RawRwLock 

pub struct RawRwLock<const RECURSIVE: bool = false> { /* private fields */ }

Raw reader-writer lock type backed by the parking lot.

If RECURSIVE is true, readers are prioritized over writers: acquiring a read lock is guaranteed not to block unless a writer currently holds the lock. This permits recursive read locking, but may starve writers.

Trait Implementations

impl<const RECURSIVE: bool> RawRwLock for RawRwLock<RECURSIVE>

const INIT: Self

Initial value for an unlocked RwLock.

type SharedGuard = GuardNoSend

Per-acquisition state stored in the lock guard.

type ExclusiveGuard = GuardNoSend

Per-acquisition state for an exclusive lock.

fn lock_exclusive(&self) -> Self::ExclusiveGuard

Acquires an exclusive lock, blocking the current thread until it is able to do so.

fn try_lock_exclusive(&self) -> Option<Self::ExclusiveGuard>

Attempts to acquire an exclusive lock without blocking.

unsafe fn unlock_exclusive(&self, _guard: Self::ExclusiveGuard)

Releases an exclusive lock.

fn lock_shared(&self) -> Self::SharedGuard

Acquires a shared lock, blocking the current thread until it is able to do so.

fn try_lock_shared(&self) -> Option<Self::SharedGuard>

Attempts to acquire a shared lock without blocking.

unsafe fn unlock_shared(&self, _guard: Self::SharedGuard)

Releases a shared lock.

fn is_locked(&self) -> bool

Checks if this RwLock is currently locked in any way.

fn is_locked_exclusive(&self) -> bool

Check if this RwLock is currently exclusively locked.

impl<const RECURSIVE: bool> RawRwLockDowngrade for RawRwLock<RECURSIVE>

unsafe fn downgrade(&self, guard: Self::ExclusiveGuard) -> Self::SharedGuard

Atomically downgrades an exclusive lock into a shared lock without allowing any thread to take an exclusive lock in the meantime.

impl<const RECURSIVE: bool> RawRwLockFair for RawRwLock<RECURSIVE>

unsafe fn unlock_shared_fair(&self, guard: Self::SharedGuard)

Releases a shared lock using a fair unlock protocol.

unsafe fn unlock_exclusive_fair(&self, _guard: Self::ExclusiveGuard)

Releases an exclusive lock using a fair unlock protocol.

unsafe fn bump_shared(&self, _guard: &mut Self::SharedGuard)

Temporarily yields a shared lock to a waiting thread if there is one.

unsafe fn bump_exclusive(&self, _guard: &mut Self::ExclusiveGuard)

Temporarily yields an exclusive lock to a waiting thread if there is one.

impl<const RECURSIVE: bool> RawRwLockTimed for RawRwLock<RECURSIVE>

type Duration = Duration

Duration type used for try_lock_for.

type Instant = Instant

Instant type used for try_lock_until.

fn try_lock_shared_for( &self, timeout: Self::Duration, ) -> Option<Self::SharedGuard>

Attempts to acquire a shared lock until a timeout is reached.

fn try_lock_shared_until( &self, timeout: Self::Instant, ) -> Option<Self::SharedGuard>

Attempts to acquire a shared lock until a timeout is reached.

fn try_lock_exclusive_for( &self, timeout: Duration, ) -> Option<Self::ExclusiveGuard>

Attempts to acquire an exclusive lock until a timeout is reached.

fn try_lock_exclusive_until( &self, timeout: Instant, ) -> Option<Self::ExclusiveGuard>

Attempts to acquire an exclusive lock until a timeout is reached.

impl<const RECURSIVE: bool> RawRwLockUpgrade for RawRwLock<RECURSIVE>

type UpgradableGuard = GuardNoSend

Per-acquisition state for an upgradable read lock.

fn lock_upgradable(&self) -> Self::UpgradableGuard

Acquires an upgradable lock, blocking the current thread until it is able to do so.

fn try_lock_upgradable(&self) -> Option<Self::UpgradableGuard>

Attempts to acquire an upgradable lock without blocking.

unsafe fn unlock_upgradable(&self, _guard: Self::UpgradableGuard)

Releases an upgradable lock.

unsafe fn upgrade(&self, guard: Self::UpgradableGuard) -> Self::ExclusiveGuard

Upgrades an upgradable lock to an exclusive lock.

unsafe fn try_upgrade( &self, guard: Self::UpgradableGuard, ) -> Result<Self::ExclusiveGuard, Self::UpgradableGuard>

Attempts to upgrade an upgradable lock to an exclusive lock without blocking.

impl<const RECURSIVE: bool> RawRwLockUpgradeDowngrade for RawRwLock<RECURSIVE>

unsafe fn downgrade_upgradable( &self, guard: Self::UpgradableGuard, ) -> Self::SharedGuard

Downgrades an upgradable lock to a shared lock.

unsafe fn downgrade_to_upgradable( &self, guard: Self::ExclusiveGuard, ) -> Self::UpgradableGuard

Downgrades an exclusive lock to an upgradable lock.

impl<const RECURSIVE: bool> RawRwLockUpgradeFair for RawRwLock<RECURSIVE>

unsafe fn unlock_upgradable_fair(&self, _guard: Self::UpgradableGuard)

Releases an upgradable lock using a fair unlock protocol.

unsafe fn bump_upgradable(&self, _guard: &mut Self::UpgradableGuard)

Temporarily yields an upgradable lock to a waiting thread if there is one.

impl<const RECURSIVE: bool> RawRwLockUpgradeTimed for RawRwLock<RECURSIVE>

fn try_lock_upgradable_until( &self, timeout: Instant, ) -> Option<Self::UpgradableGuard>

Attempts to acquire an upgradable lock until a timeout is reached.

fn try_lock_upgradable_for( &self, timeout: Duration, ) -> Option<Self::UpgradableGuard>

Attempts to acquire an upgradable lock until a timeout is reached.

unsafe fn try_upgrade_until( &self, guard: Self::UpgradableGuard, timeout: Instant, ) -> Result<Self::ExclusiveGuard, Self::UpgradableGuard>

Attempts to upgrade an upgradable lock to an exclusive lock until a timeout is reached.

unsafe fn try_upgrade_for( &self, guard: Self::UpgradableGuard, timeout: Duration, ) -> Result<Self::ExclusiveGuard, Self::UpgradableGuard>

Attempts to upgrade an upgradable lock to an exclusive lock until a timeout is reached.