Struct tracing_core::stdlib::sync::ReentrantLock

source ·
pub struct ReentrantLock<T>
where T: ?Sized,
{ mutex: Mutex, owner: AtomicUsize, lock_count: UnsafeCell<u32>, data: T, }
🔬This is a nightly-only experimental API. (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!"));
});

Fields§

§mutex: Mutex
🔬This is a nightly-only experimental API. (reentrant_lock #121440)
§owner: AtomicUsize
🔬This is a nightly-only experimental API. (reentrant_lock #121440)
§lock_count: UnsafeCell<u32>
🔬This is a nightly-only experimental API. (reentrant_lock #121440)
§data: T
🔬This is a nightly-only experimental API. (reentrant_lock #121440)

Implementations§

source§

impl<T> ReentrantLock<T>

source

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

🔬This is a nightly-only experimental API. (reentrant_lock #121440)

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

pub fn into_inner(self) -> T

🔬This is a nightly-only experimental API. (reentrant_lock #121440)

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

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

source

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

🔬This is a nightly-only experimental API. (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);
source

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

🔬This is a nightly-only experimental API. (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.

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

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

Trait Implementations§

source§

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

source§

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

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

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

source§

fn default() -> ReentrantLock<T>

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

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

source§

fn from(t: T) -> ReentrantLock<T>

Converts to this type from the input type.
source§

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

source§

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

source§

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

source§

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

Auto Trait Implementations§

§

impl<T> !Freeze for ReentrantLock<T>

§

impl<T> Unpin for ReentrantLock<T>
where T: Unpin + ?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.