Type Definition kernel::sync::lock::mutex::Mutex

pub type Mutex<T> = Lock<T, MutexBackend>;

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.

Examples

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,
}

#[pin_data]
struct Example {
    c: u32,
    #[pin]
    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;
}