Struct kernel::sync::Mutex

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

Exposes the kernel’s struct mutex. When multiple threads attempt to lock the same mutex, only one at a time is allowed to progress, the others will block (sleep) until the mutex is unlocked, at which point another thread will be allowed to wake up and make progress.

A Mutex must first be initialised with a call to Mutex::init_lock before it can be used. The mutex_init macro is provided to automatically assign a new lock class to a mutex instance.

Since it may block, Mutex needs to be used with care in atomic contexts.

Implementations

impl<T> Mutex<T>

pub const unsafe fn new(t: T) -> Self

Constructs a new mutex.

Safety

The caller must call Mutex::init_lock before using the mutex.

impl<T: ?Sized> Mutex<T>

pub fn lock(&self) -> Guard<'_, Self>

Locks the mutex and gives the caller access to the data protected by it. Only one thread at a time is allowed to access the protected data.

Trait Implementations

impl<T: ?Sized> Lock<WriteLock> for Mutex<T>

type Inner = T

The type of the data protected by the lock.

type GuardContext = EmptyGuardContext

The type of context, if any, that needs to be stored in the guard.

fn lock_noguard(&self) -> EmptyGuardContext

Acquires the lock, making the caller its owner.

unsafe fn unlock(&self, _: &mut EmptyGuardContext)

Releases the lock, giving up ownership of the lock.

fn locked_data(&self) -> &UnsafeCell<T>

Returns the data protected by the lock.

fn relock(&self, ctx: &mut Self::GuardContext)

Reacquires the lock, making the caller its owner.

impl<T> LockFactory for Mutex<T>

type LockedType<U> = Mutex<U>

The parametrised type of the mutual exclusion primitive that can be created by this factory.

unsafe fn new_lock<U>(data: U) -> Mutex<U>

Constructs a new instance of the mutual exclusion primitive.

impl<T> LockIniter for Mutex<T>

fn init_lock(
    self: Pin<&mut Self>,
    name: &'static CStr,
    key: &'static LockClassKey
)

Initialises the lock instance so that it can be safely used.

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

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