Struct process_sync::SharedMutex

pub struct SharedMutex { /* private fields */ }

Simple mutex that can be shared between processes.

This mutex is NOT recursive, so it will deadlock on relock.

Dropping mutex in creating process while mutex being locked or waited is undefined behaviour. It is recommended to drop this mutex in creating process only after no other process has access to it.

For more information see pthread_mutex_init, pthread_mutex_lock and SharedMemoryObject.

Example

let mut mutex = SharedMutex::new()?;

let pid = unsafe { fork() };
assert!(pid >= 0);

if pid == 0 {
    println!("child lock()");
    mutex.lock()?;
    println!("child locked");
    sleep(Duration::from_millis(40));
    println!("child unlock()");
    mutex.unlock()?;
} else {
    sleep(Duration::from_millis(20));
    println!("parent lock()");
    mutex.lock()?;
    println!("parent locked");
    sleep(Duration::from_millis(20));
    println!("parent unlock()");
    mutex.unlock()?;
}

Output:

child lock()
child locked
parent lock()
child unlock()
parent locked
parent unlock()

Implementations

impl SharedMutex

pub fn new() -> Result<Self>

Creates new SharedMutex

Errors

If allocation or mutex initialization fails returns error from last_os_error.

pub fn lock(&mut self) -> Result<()>

Locks mutex.

This function will block until mutex is locked.

pub fn unlock(&mut self) -> Result<()>

Unlocks mutex.

This function must be called from the same process that called lock previously.

Trait Implementations

impl Drop for SharedMutex

fn drop(&mut self)

Executes the destructor for this type.