Struct ruspiro_lock::sync::Mutex

#[repr(C, align(16))]
pub struct Mutex<T: ?Sized> { /* fields omitted */ }

An mutual exclusive access lock for the interior data

Implementations

impl<T> Mutex<T>

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

Create a new data access guarding lock

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

Try to lock the interior data for mutual exclusive access. Returns None if the lock failes or Some(MutexGuard). The actual data, the MutexGuard wraps could be conviniently accessed by dereferencing it.

Example

static DATA: Mutex<u32> = Mutex::new(10);
    if let Some(data) = DATA.try_lock() {
        // do something with data
    }

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

Lock the guarded data for mutual exclusive access. This blocks until the data could be successfully locked. The locked data will be returned as MutexGuard. Simply dereferencing this allows access to the contained data value.

Example

static DATA: Mutex<u32> = Mutex::new(10);
    let mut data = DATA.lock();
    // do something with data
    *data = 15;

pub fn into_inner(self) -> T where
    T: Sized, 

Consume the Mutex and return the inner value

Trait Implementations

impl<T> Debug for Mutex<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T> Sync for Mutex<T>

The Mutex is always Sync, to make it Send as well it need to be wrapped into an Arc.