Struct kernel::sync::smutex::Mutex

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

A simple mutex.

This is mutual-exclusion primitive. It guarantees that only one thread at a time may access the data it protects. 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.

Examples

struct Example {
    a: u32,
    b: u32,
}

static EXAMPLE: Mutex<Example> = Mutex::new(Example { a: 10, b: 20 });

fn inc_a(example: &Mutex<Example>) {
    let mut guard = example.lock();
    guard.a += 1;
}

fn sum(example: &Mutex<Example>) -> u32 {
    let guard = example.lock();
    guard.a + guard.b
}

fn try_new(a: u32, b: u32) -> Result<Ref<Mutex<Example>>> {
    Ref::try_new(Mutex::new(Example { a, b }))
}

assert_eq!(EXAMPLE.lock().a, 10);
assert_eq!(sum(&EXAMPLE), 30);

inc_a(&EXAMPLE);

assert_eq!(EXAMPLE.lock().a, 11);
assert_eq!(sum(&EXAMPLE), 31);

Implementations

impl<T> Mutex<T>

pub const fn new(data: T) -> Self

Creates a new instance of 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>