Struct ReentrantLock

pub struct ReentrantLock<T: ?Sized> { pub(in ::sync::reentrant_lock) mutex: Mutex, pub(in ::sync::reentrant_lock) owner: Tid, pub(in ::sync::reentrant_lock) lock_count: UnsafeCell<u32>, pub(in ::sync::reentrant_lock) data: T }

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!"));
});

Fields

mutex: Mutex
owner: Tid
lock_count: UnsafeCell<u32>
data: T

Implementations

impl<T> ReentrantLock<T>

const fn new(t: T) -> ReentrantLock<T>

Creates a new re-entrant lock in an unlocked state ready for use.

Examples

#![feature(reentrant_lock)]
use std::sync::ReentrantLock;

let lock = ReentrantLock::new(0);

fn into_inner(self) -> T

Consumes this lock, returning the underlying data.

Examples

#![feature(reentrant_lock)]

use std::sync::ReentrantLock;

let lock = ReentrantLock::new(0);
assert_eq!(lock.into_inner(), 0);

impl<T: ?Sized> ReentrantLock<T>

fn lock(&self) -> ReentrantLockGuard<'_, T>

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);

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

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.

Examples

#![feature(reentrant_lock)]
use std::sync::ReentrantLock;

let mut lock = ReentrantLock::new(0);
*lock.get_mut() = 10;
assert_eq!(*lock.lock(), 10);

fn try_lock(&self) -> Option<ReentrantLockGuard<'_, T>>

Attempts to acquire this lock.

If the lock could not be acquired at this time, then None is returned. Otherwise, an RAII guard is returned.

This function does not block.

const fn data_ptr(&self) -> *const T

Returns a raw pointer to the underlying data.

The returned pointer is always non-null and properly aligned, but it is the user's responsibility to ensure that any reads through it are properly synchronized to avoid data races, and that it is not read through after the lock is dropped.

unsafe fn increment_lock_count(&self) -> Option<()>

Trait Implementations

impl<T> From<T> for ReentrantLock<T>

fn from(t: T) -> Self

impl<T: Debug + ?Sized> Debug for ReentrantLock<T>

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

impl<T: Default> Default for ReentrantLock<T>

fn default() -> Self

impl<T: RefUnwindSafe + ?Sized> RefUnwindSafe for ReentrantLock<T>

impl<T: Send + ?Sized> Send for ReentrantLock<T>

impl<T: Send + ?Sized> Sync for ReentrantLock<T>

impl<T: UnwindSafe + ?Sized> UnwindSafe for ReentrantLock<T>

Auto Trait Implementations

impl<T> !Freeze for ReentrantLock<T>

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

impl<T> UnsafeUnpin for ReentrantLock<T> where T: UnsafeUnpin + ?Sized,

Blanket Implementations

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

impl<T> From<T> for ReentrantLock<T>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> From<never> for ReentrantLock<T>

fn from(t: never) -> T

impl<T> SizeHint for ReentrantLock<T> where T: ?Sized,

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

impl<T> SizedTypeProperties for ReentrantLock<T>

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

fn into(self) -> U

Calls U::from(self).

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

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

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

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

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