Struct Mutex 

pub struct Mutex<T, R = NoopRawMutex>
where
    T: ?Sized,
{ /* private fields */ }

Blocking mutex (not async)

Provides a blocking mutual exclusion primitive backed by an implementation of [raw::RawMutex].

Which implementation you select depends on the context in which you’re using the mutex, and you can choose which kind of interior mutability fits your use case.

Use [CriticalSectionMutex] when data can be shared between threads and interrupts.

Use [NoopMutex] when data is only shared between tasks running on the same executor.

Use [ThreadModeMutex] when data is shared between tasks running on the same executor but you want a global singleton.

In all cases, the blocking mutex is intended to be short lived and not held across await points. Use the async Mutex if you need a lock that is held across await points.

Implementations

impl<T, R> Mutex<T, R>

where R: RawMutex,

pub const fn new(val: T) -> Mutex<T, R>

Creates a new mutex in an unlocked state ready for use.

pub fn init<I>(val: I) -> impl Init<Mutex<T, R>>

where I: Init<T>,

Creates a mutex in-place initializer in an unlocked state ready for use.

pub fn lock<U>(&self, f: impl FnOnce(&T) -> U) -> U

Creates a critical section and grants temporary access to the protected data.

impl<T, R> Mutex<T, R>

pub const fn const_new(raw_mutex: R, val: T) -> Mutex<T, R>

Creates a new mutex based on a pre-existing raw mutex.

This allows creating a mutex in a constant context on stable Rust.

pub fn into_inner(self) -> T

Consumes this mutex, returning the underlying data.

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

Returns a mutable reference to the underlying data.

Since this call borrows the Mutex mutably, no actual locking needs to take place—the mutable borrow statically guarantees no locks exist.

Trait Implementations

impl<T, R> Send for Mutex<T, R>

where T: Send + ?Sized, R: RawMutex + Send,

impl<T, R> Sync for Mutex<T, R>

where T: Send + ?Sized, R: RawMutex + Sync,