Struct gstd::sync::Mutex

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

A mutual exclusion primitive useful for protecting shared data.

This mutex will block the execution waiting for the lock to become available. The mutex can be created via a new constructor. Each mutex has a type parameter which represents the data that it is protecting. The data can only be accessed through the RAII guard MutexGuard returned from lock, which guarantees that data access only occurs when the mutex is locked.

Examples

This example (program A), after locking the mutex, sends the PING message to another program (program B) and waits for a reply. If any other program (program C) tries to invoke program A, it will wait until program A receives the PONG reply from program B and unlocks the mutex.

use gstd::{msg, sync::Mutex, ActorId};

static mut DEST: ActorId = ActorId::zero();
static MUTEX: Mutex<()> = Mutex::new(());

#[no_mangle]
extern "C" fn init() {
    // `some_address` can be obtained from the init payload
    # let some_address = ActorId::zero();
    unsafe { DEST = some_address };
}

#[gstd::async_main]
async fn main() {
    let payload = msg::load_bytes().expect("Unable to load payload bytes");
    if payload == b"START" {
        let _unused = MUTEX.lock().await;

        let reply = msg::send_bytes_for_reply(unsafe { DEST }, b"PING", 0, 0)
            .expect("Unable to send bytes")
            .await
            .expect("Error in async message processing");

        if reply == b"PONG" {
            msg::reply(b"SUCCESS", 0).unwrap();
        } else {
            msg::reply(b"FAIL", 0).unwrap();
        }
    }
}
# fn main() {}

Implementations

impl<T> Mutex<T>

pub const fn new(t: T) -> Mutex<T>

Create a new mutex in an unlocked state ready for use.

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

Acquire a mutex, protecting the subsequent code from execution by other actors until the mutex hasn’t been unlocked.

This function will block access to the section of code by other programs or users that invoke the same program. If another actor reaches the code blocked by the mutex, it goes to the wait state until the mutex unlocks. RAII guard wrapped in the future is returned to allow scoped unlock of the lock. When the guard goes out of scope, the mutex will be unlocked.

Trait Implementations

impl<T: Default> Default for Mutex<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> From<T> for Mutex<T>

fn from(t: T) -> Self

Converts to this type from the input type.

impl<T> Sync for Mutex<T>