Struct Mutex

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

An async mutex. This is similar to the Mutex type in the standard library, but it is async.

This type only implements Sync when T is Send. Values are provided through the Deref and DerefMut implementations on the Guard type.

Examples

use no_std_async::Mutex;

static COUNT: Mutex<u8> = Mutex::new(0);

// These functions will each trade the lock, counting it up to infinity (in this case, u8::MAX).

async fn task_1() {
    loop {
        let mut count = COUNT.lock().await;
        if *count == u8::MAX {
            break;
        }
        let expected = *count + 1;
        *count += 1;
        assert_eq!(expected, *count); // we have the lock, so our value can't be modified otherwise.
    }
}

async fn task_2() {
   loop {
      let mut count = COUNT.lock().await;
      if *count == u8::MAX {
          break;
      }
      let expected = *count + 1;
      *count += 1;
      assert_eq!(expected, *count); // we have the lock, so our value can't be modified otherwise.
  }
}

Implementations

impl<T> Mutex<T>

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

Creates a new Mutex with the given data.

pub async fn lock<'a>(&'a self) -> Guard<'a, T>

where T: 'a,

Acquires a lock on the data.

Trait Implementations

impl<T: Send> Send for Mutex<T>

impl<T: Send> Sync for Mutex<T>