pub struct INFO_CACHE_MANAGER {
__private_field: (),
}
Fields
__private_field: ()
Methods from Deref<Target = RwLock<BlockCacheManager>>
pub fn read(&self) -> RwLockReadGuard<'_, T>
pub fn read(&self) -> RwLockReadGuard<'_, 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. This method does not provide any guarantees with respect to the ordering of whether contentious readers or writers will acquire the lock first.
Returns an RAII guard which will release this thread’s shared access once it is dropped.
let mylock = spin::RwLock::new(0);
{
let mut data = mylock.read();
// The lock is now locked and the data can be read
println!("{}", *data);
// The lock is dropped
}
Attempt to acquire this lock with shared read access.
This function will never block and will return immediately if read
would otherwise succeed. Returns Some
of an RAII guard which will
release the shared access of this thread when dropped, or None
if the
access could not be granted. This method does not provide any
guarantees with respect to the ordering of whether contentious readers
or writers will acquire the lock first.
let mylock = spin::RwLock::new(0);
{
match mylock.try_read() {
Some(data) => {
// The lock is now locked and the data can be read
println!("{}", *data);
// The lock is dropped
},
None => (), // no cigar
};
}
pub fn reader_count(&self) -> usize
pub fn reader_count(&self) -> usize
Return the number of readers that currently hold the lock (including upgradable readers).
Safety
This function provides no synchronization guarantees and so its result should be considered ‘out of date’ the instant it is called. Do not use it for synchronization purposes. However, it may be useful as a heuristic.
pub fn writer_count(&self) -> usize
pub fn writer_count(&self) -> usize
Return the number of writers that currently hold the lock.
Because [RwLock
] guarantees exclusive mutable access, this function may only return either 0
or 1
.
Safety
This function provides no synchronization guarantees and so its result should be considered ‘out of date’ the instant it is called. Do not use it for synchronization purposes. However, it may be useful as a heuristic.
pub unsafe fn force_read_decrement(&self)
pub unsafe fn force_read_decrement(&self)
Force decrement the reader count.
Safety
This is extremely unsafe if there are outstanding RwLockReadGuard
s
live, or if called more times than read
has been called, but can be
useful in FFI contexts where the caller doesn’t know how to deal with
RAII. The underlying atomic operation uses Ordering::Release
.
pub unsafe fn force_write_unlock(&self)
pub unsafe fn force_write_unlock(&self)
Force unlock exclusive write access.
Safety
This is extremely unsafe if there are outstanding RwLockWriteGuard
s
live, or if called when there are current readers, but can be useful in
FFI contexts where the caller doesn’t know how to deal with RAII. The
underlying atomic operation uses Ordering::Release
.
pub fn write(&self) -> RwLockWriteGuard<'_, T>
pub fn write(&self) -> RwLockWriteGuard<'_, T>
Lock 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.
let mylock = spin::RwLock::new(0);
{
let mut data = mylock.write();
// The lock is now locked and the data can be written
*data += 1;
// The lock is dropped
}
Attempt to lock this rwlock with exclusive write access.
This function does not ever block, and it will return None
if a call
to write
would otherwise block. If successful, an RAII guard is
returned.
let mylock = spin::RwLock::new(0);
{
match mylock.try_write() {
Some(mut data) => {
// The lock is now locked and the data can be written
*data += 1;
// The lock is implicitly dropped
},
None => (), // no cigar
};
}
pub fn upgradeable_read(&self) -> RwLockUpgradableGuard<'_, T>
pub fn upgradeable_read(&self) -> RwLockUpgradableGuard<'_, T>
Obtain a readable lock guard that can later be upgraded to a writable lock guard.
Upgrades can be done through the RwLockUpgradableGuard::upgrade
method.
pub fn try_upgradeable_read(&self) -> Option<RwLockUpgradableGuard<'_, T>>
pub fn try_upgradeable_read(&self) -> Option<RwLockUpgradableGuard<'_, T>>
Tries to obtain an upgradeable lock guard.
Trait Implementations
type Target = RwLock<BlockCacheManager>
type Target = RwLock<BlockCacheManager>
The resulting type after dereferencing.
Dereferences the value.