Struct embassy_sync::blocking_mutex::Mutex

pub struct Mutex<R, 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<R: RawMutex, T> Mutex<R, T>

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

Creates a new mutex 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<R, T> Mutex<R, T>

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

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.

impl<T> Mutex<CriticalSectionRawMutex, T>

pub fn borrow<'cs>(&'cs self, _cs: CriticalSection<'cs>) -> &'cs T

Borrows the data for the duration of the critical section

impl<T> Mutex<NoopRawMutex, T>

pub fn borrow(&self) -> &T

Borrows the data

Trait Implementations

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

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