Struct embassy_sync::mutex::Mutex

pub struct Mutex<M, T>
where
    M: RawMutex,
    T: ?Sized,
{ /* private fields */ }

Async mutex.

The mutex is generic over a blocking RawMutex. The raw mutex is used to guard access to the internal “is locked” flag. It is held for very short periods only, while locking and unlocking. It is not held for the entire time the async Mutex is locked.

Which implementation you select depends on the context in which you’re using the mutex.

Use CriticalSectionRawMutex when data can be shared between threads and interrupts.

Use NoopRawMutex when data is only shared between tasks running on the same executor.

Use ThreadModeRawMutex when data is shared between tasks running on the same executor but you want a singleton.

Implementations

impl<M, T> Mutex<M, T>

where M: RawMutex,

Async mutex.

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

Create a new mutex with the given value.

impl<M, T> Mutex<M, T>

where M: RawMutex, T: ?Sized,

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

Lock the mutex.

This will wait for the mutex to be unlocked if it’s already locked.

pub fn try_lock(&self) -> Result<MutexGuard<'_, M, T>, TryLockError>

Attempt to immediately lock the mutex.

If the mutex is already locked, this will return an error instead of waiting.

pub fn into_inner(self) -> T

where T: Sized,

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<M: RawMutex + Send, T: ?Sized + Send> Send for Mutex<M, T>

impl<M: RawMutex + Sync, T: ?Sized + Send> Sync for Mutex<M, T>