logo
pub struct Mutex<T> where
    T: ?Sized
{ /* private fields */ }
Expand description

An async mutex.

The locking mechanism uses eventual fairness to ensure locking will be fair on average without sacrificing performance. This is done by forcing a fair lock whenever a lock operation is starved for longer than 0.5 milliseconds.

Examples

use async_lock::Mutex;

let m = Mutex::new(1);

let mut guard = m.lock().await;
*guard = 2;

assert!(m.try_lock().is_none());
drop(guard);
assert_eq!(*m.try_lock().unwrap(), 2);

Implementations

Creates a new async mutex.

Examples
use async_lock::Mutex;

let mutex = Mutex::new(0);

Consumes the mutex, returning the underlying data.

Examples
use async_lock::Mutex;

let mutex = Mutex::new(10);
assert_eq!(mutex.into_inner(), 10);

Acquires the mutex.

Returns a guard that releases the mutex when dropped.

Examples
use async_lock::Mutex;

let mutex = Mutex::new(10);
let guard = mutex.lock().await;
assert_eq!(*guard, 10);

Attempts to acquire the mutex.

If the mutex could not be acquired at this time, then None is returned. Otherwise, a guard is returned that releases the mutex when dropped.

Examples
use async_lock::Mutex;

let mutex = Mutex::new(10);
if let Some(guard) = mutex.try_lock() {
    assert_eq!(*guard, 10);
}

Returns a mutable reference to the underlying data.

Since this call borrows the mutex mutably, no actual locking takes place – the mutable borrow statically guarantees the mutex is not already acquired.

Examples
use async_lock::Mutex;

let mut mutex = Mutex::new(0);
*mutex.get_mut() = 10;
assert_eq!(*mutex.lock().await, 10);

Acquires the mutex and clones a reference to it.

Returns an owned guard that releases the mutex when dropped.

Examples
use async_lock::Mutex;
use std::sync::Arc;

let mutex = Arc::new(Mutex::new(10));
let guard = mutex.lock_arc().await;
assert_eq!(*guard, 10);

Attempts to acquire the mutex and clone a reference to it.

If the mutex could not be acquired at this time, then None is returned. Otherwise, an owned guard is returned that releases the mutex when dropped.

Examples
use async_lock::Mutex;
use std::sync::Arc;

let mutex = Arc::new(Mutex::new(10));
if let Some(guard) = mutex.try_lock() {
    assert_eq!(*guard, 10);
}

Trait Implementations

Formats the value using the given formatter. Read more

Returns the “default value” for a type. Read more

Performs the conversion.

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Performs the conversion.

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.