Struct MutexGuard

#[must_use = "if unused the Mutex will immediately unlock"]
pub struct MutexGuard<'a, 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: ?Sized> MutexGuard<'a, T>

fn map<U, F>(this: Self, f: F) -> MappedMutexGuard<'a, U>
where
    U: ?Sized,
    F: FnOnce(&mut T) -> &mut U,

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

# #[tokio::main(flavor = "current_thread")]
# async fn main() {
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);
# }

fn try_map<U, F>(this: Self, f: F) -> Result<MappedMutexGuard<'a, U>, Self>
where
    U: ?Sized,
    F: FnOnce(&mut T) -> Option<&mut U>,

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

# #[tokio::main(flavor = "current_thread")]
# async fn main() {
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);
# }

fn mutex(this: &Self) -> &'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
}
#
# #[tokio::main(flavor = "current_thread")]
# async fn main() {
#     let mutex = Mutex::new(0u32);
#     let guard = mutex.lock().await;
#     let _guard = unlock_and_relock(guard).await;
# }

Trait Implementations

impl<T> Sync for MutexGuard<'_, T> where T: ?Sized + Send + Sync,

impl<T: ?Sized + Debug> Debug for MutexGuard<'_, T>

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

impl<T: ?Sized + Display> Display for MutexGuard<'_, T>

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

impl<T: ?Sized> Deref for MutexGuard<'_, T>

type Target = T;
fn deref(&self) -> &Self::Target

impl<T: ?Sized> DerefMut for MutexGuard<'_, T>

fn deref_mut(&mut self) -> &mut Self::Target

impl<T: ?Sized> Drop for MutexGuard<'_, T>

fn drop(&mut self)

Auto Trait Implementations

impl<'a, T> !RefUnwindSafe for MutexGuard<'a, T>

impl<'a, T> !UnwindSafe for MutexGuard<'a, T>

impl<'a, T> Freeze for MutexGuard<'a, T> where &'a Mutex<T>: Freeze, T: ?Sized,

impl<'a, T> Send for MutexGuard<'a, T> where &'a Mutex<T>: Send, T: ?Sized,

impl<'a, T> Unpin for MutexGuard<'a, T> where &'a Mutex<T>: Unpin, T: ?Sized,

impl<'a, T> UnsafeUnpin for MutexGuard<'a, T> where &'a Mutex<T>: UnsafeUnpin, T: ?Sized,

Blanket Implementations

impl<P, T> Receiver for MutexGuard<'a, T> where P: Deref<Target = T> + ?Sized, T: ?Sized,

type Target = T;

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

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for MutexGuard<'a, T> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for MutexGuard<'a, T> where T: ?Sized,

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

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

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToString for MutexGuard<'a, T> where T: Display + ?Sized,

fn to_string(&self) -> String

impl<T, U> Into<U> for MutexGuard<'a, T> where U: From<T>,

fn into(self) -> U

Calls U::from(self).

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

impl<T, U> TryFrom<U> for MutexGuard<'a, T> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for MutexGuard<'a, T> where U: TryFrom<T>,

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