Struct std::sync::ReentrantLock
source · pub struct ReentrantLock<T: ?Sized> { /* private fields */ }
reentrant_lock
#121440)Expand description
A re-entrant mutual exclusion lock
This lock will block other threads waiting for the lock to become available. The thread which has already locked the mutex can lock it multiple times without blocking, preventing a common source of deadlocks.
§Examples
Allow recursively calling a function needing synchronization from within
a callback (this is how StdoutLock
is currently
implemented):
#![feature(reentrant_lock)]
use std::cell::RefCell;
use std::sync::ReentrantLock;
pub struct Log {
data: RefCell<String>,
}
impl Log {
pub fn append(&self, msg: &str) {
self.data.borrow_mut().push_str(msg);
}
}
static LOG: ReentrantLock<Log> = ReentrantLock::new(Log { data: RefCell::new(String::new()) });
pub fn with_log<R>(f: impl FnOnce(&Log) -> R) -> R {
let log = LOG.lock();
f(&*log)
}
with_log(|log| {
log.append("Hello");
with_log(|log| log.append(" there!"));
});
Implementations§
source§impl<T> ReentrantLock<T>
impl<T> ReentrantLock<T>
sourcepub const fn new(t: T) -> ReentrantLock<T>
🔬This is a nightly-only experimental API. (reentrant_lock
#121440)
pub const fn new(t: T) -> ReentrantLock<T>
reentrant_lock
#121440)Creates a new re-entrant lock in an unlocked state ready for use.
§Examples
sourcepub fn into_inner(self) -> T
🔬This is a nightly-only experimental API. (reentrant_lock
#121440)
pub fn into_inner(self) -> T
reentrant_lock
#121440)Consumes this lock, returning the underlying data.
§Examples
source§impl<T: ?Sized> ReentrantLock<T>
impl<T: ?Sized> ReentrantLock<T>
sourcepub fn lock(&self) -> ReentrantLockGuard<'_, T>
🔬This is a nightly-only experimental API. (reentrant_lock
#121440)
pub fn lock(&self) -> ReentrantLockGuard<'_, T>
reentrant_lock
#121440)Acquires the lock, blocking the current thread until it is able to do so.
This function will block the caller until it is available to acquire the lock. Upon returning, the thread is the only thread with the lock held. When the thread calling this method already holds the lock, the call succeeds without blocking.
§Examples
#![feature(reentrant_lock)]
use std::cell::Cell;
use std::sync::{Arc, ReentrantLock};
use std::thread;
let lock = Arc::new(ReentrantLock::new(Cell::new(0)));
let c_lock = Arc::clone(&lock);
thread::spawn(move || {
c_lock.lock().set(10);
}).join().expect("thread::spawn failed");
assert_eq!(lock.lock().get(), 10);
sourcepub fn get_mut(&mut self) -> &mut T
🔬This is a nightly-only experimental API. (reentrant_lock
#121440)
pub fn get_mut(&mut self) -> &mut T
reentrant_lock
#121440)Returns a mutable reference to the underlying data.
Since this call borrows the ReentrantLock
mutably, no actual locking
needs to take place – the mutable borrow statically guarantees no locks
exist.