Struct Mutex

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

A mutual exclusion primitive useful for protecting shared data.

This mutex will block threads waiting for the lock to become available. This is modeled after std::sync::Mutex, and attempts to implement that API as closely as makes sense on Zephyr. Currently, it has the following differences:

• Poisoning: This does not yet implement poisoning, as there is no way to recover from panic at this time on Zephyr.
• Allocation: new is not yet provided, and will be provided once kernel object pools are implemented. Please use new_from which takes a reference to a statically allocated sys::Mutex.

Implementations

impl<T> Mutex<T>

pub const fn new_from(t: T, raw_mutex: Mutex) -> Mutex<T>

Construct a new wrapped Mutex, using the given underlying sys mutex. This is different that std::sync::Mutex in that in Zephyr, objects are frequently allocated statically, and the sys Mutex will be taken by this structure. It is safe to share the underlying Mutex between different items, but without careful use, it is easy to deadlock, so it is not recommended.

pub fn new(t: T) -> Mutex<T>

Construct a new Mutex, dynamically allocating the underlying sys Mutex.

impl<T: ?Sized> Mutex<T>

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

Acquires a mutex, blocking the current thread until it is able to do so.

This function will block the local thread until it is available to acquire the mutex. Upon returning, the thread is the only thread with the lock held. An RAII guard is returned to allow scoped unlock of the lock. When the guard goes out of scope, the mutex will be unlocked.

In std, an attempt to lock a mutex by a thread that already holds the mutex is unspecified. Zephyr explicitly supports this behavior, by simply incrementing a lock count.

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

Attempts to acquire this lock.

If the lock could not be acquired at this time, then Err is returned. Otherwise, an RAII guard is returned. The lock will be unlocked when the guard is dropped.

This function does not block.

Trait Implementations

impl<T> Debug for Mutex<T>

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

Formats the value using the given formatter.

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

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