Struct async_lock::Mutex

source ·
pub struct Mutex<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§

source§

impl<T> Mutex<T>

source

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

Creates a new async mutex.

§Examples
use async_lock::Mutex;

let mutex = Mutex::new(0);
source

pub fn into_inner(self) -> T

Consumes the mutex, returning the underlying data.

§Examples
use async_lock::Mutex;

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

impl<T: ?Sized> Mutex<T>

source

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

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);
source

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

Acquires the mutex using the blocking strategy.

Returns a guard that releases the mutex when dropped.

§Blocking

Rather than using asynchronous waiting, like the lock method, this method will block the current thread until the lock is acquired.

This method should not be used in an asynchronous context. It is intended to be used in a way that a mutex can be used in both asynchronous and synchronous contexts. Calling this method in an asynchronous context may result in a deadlock.

§Examples
use async_lock::Mutex;

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

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

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);
}
source

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

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);
source§

impl<T: ?Sized> Mutex<T>

source

pub fn lock_arc(self: &Arc<Self>) -> LockArc<T>

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);
source

pub fn lock_arc_blocking(self: &Arc<Self>) -> MutexGuardArc<T>

Acquires the mutex and clones a reference to it using the blocking strategy.

Returns an owned guard that releases the mutex when dropped.

§Blocking

Rather than using asynchronous waiting, like the lock_arc method, this method will block the current thread until the lock is acquired.

This method should not be used in an asynchronous context. It is intended to be used in a way that a mutex can be used in both asynchronous and synchronous contexts. Calling this method in an asynchronous context may result in a deadlock.

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

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

pub fn try_lock_arc(self: &Arc<Self>) -> Option<MutexGuardArc<T>>

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§

source§

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

source§

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

Formats the value using the given formatter. Read more
source§

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

source§

fn default() -> Mutex<T>

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

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

source§

fn from(val: T) -> Mutex<T>

Converts to this type from the input type.
source§

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

source§

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

Auto Trait Implementations§

§

impl<T> !Freeze for Mutex<T>

§

impl<T> !RefUnwindSafe for Mutex<T>

§

impl<T> Unpin for Mutex<T>
where T: Unpin + ?Sized,

§

impl<T> UnwindSafe for Mutex<T>
where T: UnwindSafe + ?Sized,

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<!> for T

source§

fn from(t: !) -> T

Converts to this type from the input type.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

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

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.