Struct AsyncMutexGuard

pub struct AsyncMutexGuard<'a, T>
where
    T: ?Sized,
{ /* private fields */ }

A handle to a held Mutex. The guard can be held across any .await point as it is Send.

As long as you have this guard, you have exclusive access to the underlying T. The guard internally borrows the Mutex, so the mutex will not be dropped while a guard exists.

The lock is automatically released whenever the guard is dropped, at which point lock will succeed yet again.

Implementations

impl<'a, T> MutexGuard<'a, T>

where T: ?Sized,

pub fn map<U, F>(this: MutexGuard<'a, T>, f: F) -> MappedMutexGuard<'a, U>

where F: FnOnce(&mut T) -> &mut U, U: ?Sized,

Makes a new MappedMutexGuard for a component of the locked data.

This operation cannot fail as the MutexGuard passed in already locked the mutex.

This is an associated function that needs to be used as MutexGuard::map(...). A method would interfere with methods of the same name on the contents of the locked data.

Examples

use tokio::sync::{Mutex, MutexGuard};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Foo(u32);

let foo = Mutex::new(Foo(1));

{
    let mut mapped = MutexGuard::map(foo.lock().await, |f| &mut f.0);
    *mapped = 2;
}

assert_eq!(Foo(2), *foo.lock().await);

pub fn try_map<U, F>( this: MutexGuard<'a, T>, f: F, ) -> Result<MappedMutexGuard<'a, U>, MutexGuard<'a, T>>

where F: FnOnce(&mut T) -> Option<&mut U>, U: ?Sized,

Attempts to make a new MappedMutexGuard for a component of the locked data. The original guard is returned if the closure returns None.

This operation cannot fail as the MutexGuard passed in already locked the mutex.

This is an associated function that needs to be used as MutexGuard::try_map(...). A method would interfere with methods of the same name on the contents of the locked data.

Examples

use tokio::sync::{Mutex, MutexGuard};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Foo(u32);

let foo = Mutex::new(Foo(1));

{
    let mut mapped = MutexGuard::try_map(foo.lock().await, |f| Some(&mut f.0))
        .expect("should not fail");
    *mapped = 2;
}

assert_eq!(Foo(2), *foo.lock().await);

pub fn mutex(this: &MutexGuard<'a, T>) -> &'a Mutex<T>

Returns a reference to the original Mutex.

use tokio::sync::{Mutex, MutexGuard};

async fn unlock_and_relock<'l>(guard: MutexGuard<'l, u32>) -> MutexGuard<'l, u32> {
    println!("1. contains: {:?}", *guard);
    let mutex = MutexGuard::mutex(&guard);
    drop(guard);
    let guard = mutex.lock().await;
    println!("2. contains: {:?}", *guard);
    guard
}

Trait Implementations

impl<T> Debug for MutexGuard<'_, T>

where T: Debug + ?Sized,

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

Formats the value using the given formatter.

impl<T> Deref for MutexGuard<'_, T>

where T: ?Sized,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &<MutexGuard<'_, T> as Deref>::Target

Dereferences the value.

impl<T> DerefMut for MutexGuard<'_, T>

where T: ?Sized,

fn deref_mut(&mut self) -> &mut <MutexGuard<'_, T> as Deref>::Target

Mutably dereferences the value.

impl<T> Display for MutexGuard<'_, T>

where T: Display + ?Sized,

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

Formats the value using the given formatter.

impl<T> Drop for MutexGuard<'_, T>

where T: ?Sized,

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Sync for MutexGuard<'_, T>

where T: Send + Sync + ?Sized,