Struct Mutex 

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

An asynchronous mutex that grants exclusive access in request order.

See the module level documentation for more.

Implementations

impl<T> Mutex<T>

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

Wraps t in an unlocked mutex.

Examples

use asyncband::mutex::Mutex;

let mutex = Mutex::new(5);

pub fn into_inner(self) -> T

Unwraps the protected value.

Examples

use asyncband::mutex::Mutex;

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

impl<T: ?Sized> Mutex<T>

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

Waits for exclusive access and returns a borrowed guard.

Cancel safety

Pending lock requests complete in order. Cancelling this call loses its place among them.

Examples

use asyncband::mutex::Mutex;

let mutex = Mutex::new(1);

let mut n = mutex.lock().await;
*n = 2;

pub fn try_lock(&self) -> Option<MutexGuard<'_, T>>

Acquires the mutex without waiting, or returns None when it is already held.

Examples

use asyncband::mutex::Mutex;

let mutex = Mutex::new(1);
let mut guard = mutex.try_lock().expect("mutex is locked");
*guard += 1;
assert_eq!(2, *guard);

pub async fn lock_owned(self: Arc<Self>) -> OwnedMutexGuard<T>

Waits for exclusive access and returns a guard that owns this Arc.

The owned guard keeps the mutex alive instead of borrowing it, which allows the guard to be moved wherever a 'static value is required.

Cancel safety

Pending lock requests complete in order. Cancelling this call loses its place among them.

Examples

use std::sync::Arc;

use asyncband::mutex::Mutex;

let mutex = Arc::new(Mutex::new(1));

let mut n = mutex.clone().lock_owned().await;
*n = 2;

pub fn try_lock_owned(self: Arc<Self>) -> Option<OwnedMutexGuard<T>>

Acquires the mutex without waiting and returns a guard that owns this Arc.

Returns None when another guard currently holds the mutex.

Examples

use std::sync::Arc;

use asyncband::mutex::Mutex;

let mutex = Arc::new(Mutex::new(1));
let mut guard = mutex.clone().try_lock_owned().expect("mutex is locked");
*guard += 1;
assert_eq!(2, *guard);

pub fn get_mut(&mut self) -> &mut T

Borrows the protected value mutably without locking.

The exclusive borrow of the mutex already prevents any guard from existing at the same time.

Examples

use asyncband::mutex::Mutex;

let mut mutex = Mutex::new(1);
let n = mutex.get_mut();
*n = 2;

Trait Implementations

impl<T: ?Sized + Debug> Debug for Mutex<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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: ?Sized + Send> Send for Mutex<T>

impl<T: ?Sized + Send> Sync for Mutex<T>