Struct ReentrantMutex 

pub struct ReentrantMutex<T: ?Sized> { /* private fields */ }

A mutex the owner holding it can lock again without waiting.

Each lock by the holding owner deepens a count; the mutex unlocks when the last of its guards drops, and then wakes the oldest waiting owner, with the bounded bypass of Mutex.

A guard gives &T, since two guards of one owner are alive at once; mutate through a Cell or RefCell inside. Guards and lock futures borrow their Owner, so they stay on its thread (see the Owner docs): a task that holds or awaits one is not Send meanwhile.

use nuclei::sync::{Owner, ReentrantMutex};
use std::cell::Cell;

let lock = ReentrantMutex::new(Cell::new(0));
let me = Owner::new();
let a = lock.try_lock(&me).expect("free");
let b = lock.try_lock(&me).expect("re-entered");
b.set(a.get() + 1);
drop((a, b));
assert_eq!(lock.into_inner().get(), 1);

Implementations

impl<T> ReentrantMutex<T>

pub const fn new(value: T) -> Self

An unlocked mutex holding value.

pub fn into_inner(self) -> T

Consumes the mutex and returns its value.

impl<T: ?Sized> ReentrantMutex<T>

pub fn try_lock<'a>( &'a self, owner: &'a Owner, ) -> Option<ReentrantMutexGuard<'a, T>>

Locks the mutex if owner holds it, or if it is free and no handoff is owed.

pub fn lock<'a>(&'a self, owner: &'a Owner) -> ReentrantMutexLock<'a, T>

Waits for the lock, at once if owner already holds it. A contended wait is lock-free, not wait-free: see Progress.

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

The value, borrowed mutably; &mut self proves no guard exists.

Trait Implementations

impl<T: ?Sized> Debug for ReentrantMutex<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for ReentrantMutex<T>

fn default() -> Self

Returns the “default value” for a type.

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

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