Struct lock_api::RwLock

source ·
pub struct RwLock<R, T: ?Sized> { /* private fields */ }
Expand description

A reader-writer lock

This type of lock allows a number of readers or at most one writer at any point in time. The write portion of this lock typically allows modification of the underlying data (exclusive access) and the read portion of this lock typically allows for read-only access (shared access).

The type parameter T represents the data that this lock protects. It is required that T satisfies Send to be shared across threads and Sync to allow concurrent access through readers. The RAII guards returned from the locking methods implement Deref (and DerefMut for the write methods) to allow access to the contained of the lock.

Implementations§

source§

impl<R: RawRwLock, T> RwLock<R, T>

source

pub const fn new(val: T) -> RwLock<R, T>

Creates a new instance of an RwLock<T> which is unlocked.

source

pub fn into_inner(self) -> T

Consumes this RwLock, returning the underlying data.

source§

impl<R, T> RwLock<R, T>

source

pub const fn from_raw(raw_rwlock: R, val: T) -> RwLock<R, T>

Creates a new new instance of an RwLock<T> based on a pre-existing RawRwLock<T>.

source

pub const fn const_new(raw_rwlock: R, val: T) -> RwLock<R, T>

Creates a new new instance of an RwLock<T> based on a pre-existing RawRwLock<T>.

This allows creating a RwLock<T> in a constant context on stable Rust.

This method is a legacy alias for from_raw.

source§

impl<R: RawRwLock, T: ?Sized> RwLock<R, T>

source

pub unsafe fn make_read_guard_unchecked(&self) -> RwLockReadGuard<'_, R, T>

Creates a new RwLockReadGuard without checking if the lock is held.

§Safety

This method must only be called if the thread logically holds a read lock.

This function does not increment the read count of the lock. Calling this function when a guard has already been produced is undefined behaviour unless the guard was forgotten with mem::forget.

source

pub unsafe fn make_write_guard_unchecked(&self) -> RwLockWriteGuard<'_, R, T>

Creates a new RwLockReadGuard without checking if the lock is held.

§Safety

This method must only be called if the thread logically holds a write lock.

Calling this function when a guard has already been produced is undefined behaviour unless the guard was forgotten with mem::forget.

source

pub fn read(&self) -> RwLockReadGuard<'_, R, T>

Locks this RwLock with shared read access, blocking the current thread until it can be acquired.

The calling thread will be blocked until there are no more writers which hold the lock. There may be other readers currently inside the lock when this method returns.

Note that attempts to recursively acquire a read lock on a RwLock when the current thread already holds one may result in a deadlock.

Returns an RAII guard which will release this thread’s shared access once it is dropped.

source

pub fn try_read(&self) -> Option<RwLockReadGuard<'_, R, T>>

Attempts to acquire this RwLock with shared read access.

If the access could not be granted at this time, then None is returned. Otherwise, an RAII guard is returned which will release the shared access when it is dropped.

This function does not block.

source

pub fn write(&self) -> RwLockWriteGuard<'_, R, T>

Locks this RwLock with exclusive write access, blocking the current thread until it can be acquired.

This function will not return while other writers or other readers currently have access to the lock.

Returns an RAII guard which will drop the write access of this RwLock when dropped.

source

pub fn try_write(&self) -> Option<RwLockWriteGuard<'_, R, T>>

Attempts to lock this RwLock with exclusive write access.

If the lock could not be acquired at this time, then None is returned. Otherwise, an RAII guard is returned which will release the lock when it is dropped.

This function does not block.

source

pub fn get_mut(&mut self) -> &mut T

Returns a mutable reference to the underlying data.

Since this call borrows the RwLock mutably, no actual locking needs to take place—the mutable borrow statically guarantees no locks exist.

source

pub fn is_locked(&self) -> bool

Checks whether this RwLock is currently locked in any way.

source

pub fn is_locked_exclusive(&self) -> bool

Check if this RwLock is currently exclusively locked.

source

pub unsafe fn force_unlock_read(&self)

Forcibly unlocks a read lock.

This is useful when combined with mem::forget to hold a lock without the need to maintain a RwLockReadGuard object alive, for example when dealing with FFI.

§Safety

This method must only be called if the current thread logically owns a RwLockReadGuard but that guard has be discarded using mem::forget. Behavior is undefined if a rwlock is read-unlocked when not read-locked.

source

pub unsafe fn force_unlock_write(&self)

Forcibly unlocks a write lock.

This is useful when combined with mem::forget to hold a lock without the need to maintain a RwLockWriteGuard object alive, for example when dealing with FFI.

§Safety

This method must only be called if the current thread logically owns a RwLockWriteGuard but that guard has be discarded using mem::forget. Behavior is undefined if a rwlock is write-unlocked when not write-locked.

source

pub unsafe fn raw(&self) -> &R

Returns the underlying raw reader-writer lock object.

Note that you will most likely need to import the RawRwLock trait from lock_api to be able to call functions on the raw reader-writer lock.

§Safety

This method is unsafe because it allows unlocking a mutex while still holding a reference to a lock guard.

source

pub fn data_ptr(&self) -> *mut T

Returns a raw pointer to the underlying data.

This is useful when combined with mem::forget to hold a lock without the need to maintain a RwLockReadGuard or RwLockWriteGuard object alive, for example when dealing with FFI.

§Safety

You must ensure that there are no data races when dereferencing the returned pointer, for example if the current thread logically owns a RwLockReadGuard or RwLockWriteGuard but that guard has been discarded using mem::forget.

source

pub unsafe fn make_arc_read_guard_unchecked( self: &Arc<Self> ) -> ArcRwLockReadGuard<R, T>

Creates a new RwLockReadGuard without checking if the lock is held.

§Safety

This method must only be called if the thread logically holds a read lock.

This function does not increment the read count of the lock. Calling this function when a guard has already been produced is undefined behaviour unless the guard was forgotten with mem::forget.`

source

pub unsafe fn make_arc_write_guard_unchecked( self: &Arc<Self> ) -> ArcRwLockWriteGuard<R, T>

Creates a new RwLockWriteGuard without checking if the lock is held.

§Safety

This method must only be called if the thread logically holds a write lock.

Calling this function when a guard has already been produced is undefined behaviour unless the guard was forgotten with mem::forget.

source

pub fn read_arc(self: &Arc<Self>) -> ArcRwLockReadGuard<R, T>

Locks this RwLock with read access, through an Arc.

This method is similar to the read method; however, it requires the RwLock to be inside of an Arc and the resulting read guard has no lifetime requirements.

source

pub fn try_read_arc(self: &Arc<Self>) -> Option<ArcRwLockReadGuard<R, T>>

Attempts to lock this RwLock with read access, through an Arc.

This method is similar to the try_read method; however, it requires the RwLock to be inside of an Arc and the resulting read guard has no lifetime requirements.

source

pub fn write_arc(self: &Arc<Self>) -> ArcRwLockWriteGuard<R, T>

Locks this RwLock with write access, through an Arc.

This method is similar to the write method; however, it requires the RwLock to be inside of an Arc and the resulting write guard has no lifetime requirements.

source

pub fn try_write_arc(self: &Arc<Self>) -> Option<ArcRwLockWriteGuard<R, T>>

Attempts to lock this RwLock with writ access, through an Arc.

This method is similar to the try_write method; however, it requires the RwLock to be inside of an Arc and the resulting write guard has no lifetime requirements.

source§

impl<R: RawRwLockFair, T: ?Sized> RwLock<R, T>

source

pub unsafe fn force_unlock_read_fair(&self)

Forcibly unlocks a read lock using a fair unlock protocol.

This is useful when combined with mem::forget to hold a lock without the need to maintain a RwLockReadGuard object alive, for example when dealing with FFI.

§Safety

This method must only be called if the current thread logically owns a RwLockReadGuard but that guard has be discarded using mem::forget. Behavior is undefined if a rwlock is read-unlocked when not read-locked.

source

pub unsafe fn force_unlock_write_fair(&self)

Forcibly unlocks a write lock using a fair unlock protocol.

This is useful when combined with mem::forget to hold a lock without the need to maintain a RwLockWriteGuard object alive, for example when dealing with FFI.

§Safety

This method must only be called if the current thread logically owns a RwLockWriteGuard but that guard has be discarded using mem::forget. Behavior is undefined if a rwlock is write-unlocked when not write-locked.

source§

impl<R: RawRwLockTimed, T: ?Sized> RwLock<R, T>

source

pub fn try_read_for( &self, timeout: R::Duration ) -> Option<RwLockReadGuard<'_, R, T>>

Attempts to acquire this RwLock with shared read access until a timeout is reached.

If the access could not be granted before the timeout expires, then None is returned. Otherwise, an RAII guard is returned which will release the shared access when it is dropped.

source

pub fn try_read_until( &self, timeout: R::Instant ) -> Option<RwLockReadGuard<'_, R, T>>

Attempts to acquire this RwLock with shared read access until a timeout is reached.

If the access could not be granted before the timeout expires, then None is returned. Otherwise, an RAII guard is returned which will release the shared access when it is dropped.

source

pub fn try_write_for( &self, timeout: R::Duration ) -> Option<RwLockWriteGuard<'_, R, T>>

Attempts to acquire this RwLock with exclusive write access until a timeout is reached.

If the access could not be granted before the timeout expires, then None is returned. Otherwise, an RAII guard is returned which will release the exclusive access when it is dropped.

source

pub fn try_write_until( &self, timeout: R::Instant ) -> Option<RwLockWriteGuard<'_, R, T>>

Attempts to acquire this RwLock with exclusive write access until a timeout is reached.

If the access could not be granted before the timeout expires, then None is returned. Otherwise, an RAII guard is returned which will release the exclusive access when it is dropped.

source

pub fn try_read_arc_for( self: &Arc<Self>, timeout: R::Duration ) -> Option<ArcRwLockReadGuard<R, T>>

Attempts to acquire this RwLock with read access until a timeout is reached, through an Arc.

This method is similar to the try_read_for method; however, it requires the RwLock to be inside of an Arc and the resulting read guard has no lifetime requirements.

source

pub fn try_read_arc_until( self: &Arc<Self>, timeout: R::Instant ) -> Option<ArcRwLockReadGuard<R, T>>

Attempts to acquire this RwLock with read access until a timeout is reached, through an Arc.

This method is similar to the try_read_until method; however, it requires the RwLock to be inside of an Arc and the resulting read guard has no lifetime requirements.

source

pub fn try_write_arc_for( self: &Arc<Self>, timeout: R::Duration ) -> Option<ArcRwLockWriteGuard<R, T>>

Attempts to acquire this RwLock with write access until a timeout is reached, through an Arc.

This method is similar to the try_write_for method; however, it requires the RwLock to be inside of an Arc and the resulting write guard has no lifetime requirements.

source

pub fn try_write_arc_until( self: &Arc<Self>, timeout: R::Instant ) -> Option<ArcRwLockWriteGuard<R, T>>

Attempts to acquire this RwLock with read access until a timeout is reached, through an Arc.

This method is similar to the try_write_until method; however, it requires the RwLock to be inside of an Arc and the resulting read guard has no lifetime requirements.

source§

impl<R: RawRwLockRecursive, T: ?Sized> RwLock<R, T>

source

pub fn read_recursive(&self) -> RwLockReadGuard<'_, R, T>

Locks this RwLock with shared read access, blocking the current thread until it can be acquired.

The calling thread will be blocked until there are no more writers which hold the lock. There may be other readers currently inside the lock when this method returns.

Unlike read, this method is guaranteed to succeed without blocking if another read lock is held at the time of the call. This allows a thread to recursively lock a RwLock. However using this method can cause writers to starve since readers no longer block if a writer is waiting for the lock.

Returns an RAII guard which will release this thread’s shared access once it is dropped.

source

pub fn try_read_recursive(&self) -> Option<RwLockReadGuard<'_, R, T>>

Attempts to acquire this RwLock with shared read access.

If the access could not be granted at this time, then None is returned. Otherwise, an RAII guard is returned which will release the shared access when it is dropped.

This method is guaranteed to succeed if another read lock is held at the time of the call. See the documentation for read_recursive for details.

This function does not block.

source

pub fn read_arc_recursive(self: &Arc<Self>) -> ArcRwLockReadGuard<R, T>

Locks this RwLock with shared read access, through an Arc.

This method is similar to the read_recursive method; however, it requires the RwLock to be inside of an Arc and the resulting read guard has no lifetime requirements.

source

pub fn try_read_recursive_arc( self: &Arc<Self> ) -> Option<ArcRwLockReadGuard<R, T>>

Attempts to lock this RwLock with shared read access, through an Arc.

This method is similar to the try_read_recursive method; however, it requires the RwLock to be inside of an Arc and the resulting read guard has no lifetime requirements.

source§

impl<R: RawRwLockRecursiveTimed, T: ?Sized> RwLock<R, T>

source

pub fn try_read_recursive_for( &self, timeout: R::Duration ) -> Option<RwLockReadGuard<'_, R, T>>

Attempts to acquire this RwLock with shared read access until a timeout is reached.

If the access could not be granted before the timeout expires, then None is returned. Otherwise, an RAII guard is returned which will release the shared access when it is dropped.

This method is guaranteed to succeed without blocking if another read lock is held at the time of the call. See the documentation for read_recursive for details.

source

pub fn try_read_recursive_until( &self, timeout: R::Instant ) -> Option<RwLockReadGuard<'_, R, T>>

Attempts to acquire this RwLock with shared read access until a timeout is reached.

If the access could not be granted before the timeout expires, then None is returned. Otherwise, an RAII guard is returned which will release the shared access when it is dropped.

source

pub fn try_read_arc_recursive_for( self: &Arc<Self>, timeout: R::Duration ) -> Option<ArcRwLockReadGuard<R, T>>

Attempts to lock this RwLock with read access until a timeout is reached, through an Arc.

This method is similar to the try_read_recursive_for method; however, it requires the RwLock to be inside of an Arc and the resulting read guard has no lifetime requirements.

source

pub fn try_read_arc_recursive_until( self: &Arc<Self>, timeout: R::Instant ) -> Option<ArcRwLockReadGuard<R, T>>

Attempts to lock this RwLock with read access until a timeout is reached, through an Arc.

This method is similar to the try_read_recursive_until method; however, it requires the RwLock to be inside of an Arc and the resulting read guard has no lifetime requirements.

source§

impl<R: RawRwLockUpgrade, T: ?Sized> RwLock<R, T>

source

pub unsafe fn make_upgradable_guard_unchecked( &self ) -> RwLockUpgradableReadGuard<'_, R, T>

Creates a new RwLockUpgradableReadGuard without checking if the lock is held.

§Safety

This method must only be called if the thread logically holds an upgradable read lock.

This function does not increment the read count of the lock. Calling this function when a guard has already been produced is undefined behaviour unless the guard was forgotten with mem::forget.

source

pub fn upgradable_read(&self) -> RwLockUpgradableReadGuard<'_, R, T>

Locks this RwLock with upgradable read access, blocking the current thread until it can be acquired.

The calling thread will be blocked until there are no more writers or other upgradable reads which hold the lock. There may be other readers currently inside the lock when this method returns.

Returns an RAII guard which will release this thread’s shared access once it is dropped.

source

pub fn try_upgradable_read(&self) -> Option<RwLockUpgradableReadGuard<'_, R, T>>

Attempts to acquire this RwLock with upgradable read access.

If the access could not be granted at this time, then None is returned. Otherwise, an RAII guard is returned which will release the shared access when it is dropped.

This function does not block.

source

pub unsafe fn make_upgradable_arc_guard_unchecked( self: &Arc<Self> ) -> ArcRwLockUpgradableReadGuard<R, T>

Creates a new ArcRwLockUpgradableReadGuard without checking if the lock is held.

§Safety

This method must only be called if the thread logically holds an upgradable read lock.

This function does not increment the read count of the lock. Calling this function when a guard has already been produced is undefined behaviour unless the guard was forgotten with mem::forget.`

source

pub fn upgradable_read_arc( self: &Arc<Self> ) -> ArcRwLockUpgradableReadGuard<R, T>

Locks this RwLock with upgradable read access, through an Arc.

This method is similar to the upgradable_read method; however, it requires the RwLock to be inside of an Arc and the resulting read guard has no lifetime requirements.

source

pub fn try_upgradable_read_arc( self: &Arc<Self> ) -> Option<ArcRwLockUpgradableReadGuard<R, T>>

Attempts to lock this RwLock with upgradable read access, through an Arc.

This method is similar to the try_upgradable_read method; however, it requires the RwLock to be inside of an Arc and the resulting read guard has no lifetime requirements.

source§

impl<R: RawRwLockUpgradeTimed, T: ?Sized> RwLock<R, T>

source

pub fn try_upgradable_read_for( &self, timeout: R::Duration ) -> Option<RwLockUpgradableReadGuard<'_, R, T>>

Attempts to acquire this RwLock with upgradable read access until a timeout is reached.

If the access could not be granted before the timeout expires, then None is returned. Otherwise, an RAII guard is returned which will release the shared access when it is dropped.

source

pub fn try_upgradable_read_until( &self, timeout: R::Instant ) -> Option<RwLockUpgradableReadGuard<'_, R, T>>

Attempts to acquire this RwLock with upgradable read access until a timeout is reached.

If the access could not be granted before the timeout expires, then None is returned. Otherwise, an RAII guard is returned which will release the shared access when it is dropped.

source

pub fn try_upgradable_read_arc_for( self: &Arc<Self>, timeout: R::Duration ) -> Option<ArcRwLockUpgradableReadGuard<R, T>>

Attempts to lock this RwLock with upgradable access until a timeout is reached, through an Arc.

This method is similar to the try_upgradable_read_for method; however, it requires the RwLock to be inside of an Arc and the resulting read guard has no lifetime requirements.

source

pub fn try_upgradable_read_arc_until( self: &Arc<Self>, timeout: R::Instant ) -> Option<ArcRwLockUpgradableReadGuard<R, T>>

Attempts to lock this RwLock with upgradable access until a timeout is reached, through an Arc.

This method is similar to the try_upgradable_read_until method; however, it requires the RwLock to be inside of an Arc and the resulting read guard has no lifetime requirements.

Trait Implementations§

source§

impl<R: RawRwLock, T: ?Sized + Debug> Debug for RwLock<R, T>

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl<R: RawRwLock, T: ?Sized + Default> Default for RwLock<R, T>

source§

fn default() -> RwLock<R, T>

Returns the “default value” for a type. Read more
source§

impl<R: RawRwLock, T> From<T> for RwLock<R, T>

source§

fn from(t: T) -> RwLock<R, T>

Converts to this type from the input type.
source§

impl<R: RawRwLock + Send, T: ?Sized + Send> Send for RwLock<R, T>

source§

impl<R: RawRwLock + Sync, T: ?Sized + Send + Sync> Sync for RwLock<R, T>

Auto Trait Implementations§

§

impl<R, T> !Freeze for RwLock<R, T>

§

impl<R, T> !RefUnwindSafe for RwLock<R, T>

§

impl<R, T> Unpin for RwLock<R, T>
where R: Unpin, T: Unpin + ?Sized,

§

impl<R, T> UnwindSafe for RwLock<R, T>
where R: UnwindSafe, T: UnwindSafe + ?Sized,

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<!> for T

source§

fn from(t: !) -> T

Converts to this type from the input type.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.