Type Alias kernel::sync::lock::mutex::Mutex

source ·
pub type Mutex<T> = Lock<T, MutexBackend>;
Expand description

A mutual exclusion primitive.

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.

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

Instances of Mutex need a lock class and to be pinned. The recommended way to create such instances is with the pin_init and new_mutex macros.


The following example shows how to declare, allocate and initialise a struct (Example) that contains an inner struct (Inner) that is protected by a mutex.

use kernel::{init::InPlaceInit, init::PinInit, new_mutex, pin_init, sync::Mutex};

struct Inner {
    a: u32,
    b: u32,

struct Example {
    c: u32,
    d: Mutex<Inner>,

impl Example {
    fn new() -> impl PinInit<Self> {
        pin_init!(Self {
            c: 10,
            d <- new_mutex!(Inner { a: 20, b: 30 }),

// Allocate a boxed `Example`.
let e = Box::pin_init(Example::new())?;
assert_eq!(e.c, 10);
assert_eq!(e.d.lock().a, 20);
assert_eq!(e.d.lock().b, 30);

The following example shows how to use interior mutability to modify the contents of a struct protected by a mutex despite only having a shared reference:

use kernel::sync::Mutex;

struct Example {
    a: u32,
    b: u32,

fn example(m: &Mutex<Example>) {
    let mut guard = m.lock();
    guard.a += 10;
    guard.b += 20;

Aliased Type§

struct Mutex<T> { /* private fields */ }



impl<T, B: Backend> Lock<T, B>


pub fn new( t: T, name: &'static CStr, key: &'static LockClassKey ) -> impl PinInit<Self>

Constructs a new lock initialiser.


impl<T: ?Sized, B: Backend> Lock<T, B>


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

Acquires the lock and gives the caller access to the data protected by it.

Trait Implementations§


impl<T: ?Sized + Send, B: Backend> Send for Lock<T, B>


impl<T: ?Sized + Send, B: Backend> Sync for Lock<T, B>