Struct Mutex 

pub struct Mutex<T>(/* private fields */);

A mutual exclusion primitive useful for protecting shared data

This mutex will block threads waiting for the lock to become available. The mutex can be created via a Mutex::new constructor. Each mutex has a type parameter <T> which represents the data that it is protecting.

The data can only be accessed through the RAII guards returned from Mutex::lock and Mutex::try_lock, which guarantees that the data is only ever accessed when the mutex is locked.

Implementations

impl<T> Mutex<T>

where T: Sized,

pub fn new(t: T) -> Self

Creates a new lock in an unlocked state ready for use.

pub fn clear_poison(&self)

Clear the poisoned state from a mutex.

If the mutex is poisoned, it will remain poisoned until this function is called. This allows recovering from a poisoned state and marking that it has recovered. For example, if the value is overwritten by a known-good value, then the mutex can be marked as un-poisoned.

If the inner type is a tokio::sync::Mutex, this function is a no-op.

pub fn is_poisoned(&self) -> bool

Returns true if the mutex is poisoned.

If the inner type is a tokio::sync::Mutex, this function will always return false

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

Acquires a mutex, blocking the current thread until it is able to do so.

This function will block the local thread until it is available to acquire the mutex. Upon returning, the thread is the only thread with the lock held. An RAII guard is returned to allow scoped unlock of the lock. When the guard goes out of scope, the mutex will be unlocked.

pub async fn try_lock( &self, ) -> Result<MutexGuard<'_, T>, TryLockError<MutexGuard<'_, T>>>

Attempts to acquire this lock.

If the lock could not be acquired at this time, then TryLockError is returned. Otherwise, an RAII guard is returned. The lock will be unlocked when the guard is dropped.

Trait Implementations

impl<T: Debug> Debug for Mutex<T>

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

Formats the value using the given formatter.

impl<T> Default for Mutex<T>

where T: Default,

fn default() -> Self

Returns the “default value” for a type.

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

fn from(mutex: Mutex<T>) -> Self

Converts to this type from the input type.

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

fn from(t: T) -> Self

Converts to this type from the input type.

impl<T> Unwrap for Mutex<T>

type StdImpl = Mutex<T>

type TokioImpl = Mutex<T>

fn unwrap_std(self) -> Self::StdImpl

Unwraps the std underlying implementation of the MaybeFut type.

fn unwrap_tokio(self) -> Self::TokioImpl

Unwraps the tokio underlying implementation of the MaybeFut type.

fn unwrap_std_ref(&self) -> &Self::StdImpl

Unwraps the std underlying implementation of the MaybeFut type as a reference.

fn unwrap_tokio_ref(&self) -> &Self::TokioImpl

Unwraps the tokio underlying implementation of the MaybeFut type as a reference.

fn unwrap_std_mut(&mut self) -> &mut Self::StdImpl

Unwraps the std underlying implementation of the MaybeFut type as a mutable reference.

fn unwrap_tokio_mut(&mut self) -> &mut Self::TokioImpl

Unwraps the tokio underlying implementation of the MaybeFut type as a mutable reference.

fn get_std(self) -> Option<Self::StdImpl>

Safely unwraps the std underlying implementation of the MaybeFut type.

fn get_tokio(self) -> Option<Self::TokioImpl>

Safely unwraps the tokio underlying implementation of the MaybeFut type.

fn get_std_ref(&self) -> Option<&Self::StdImpl>

Safely unwraps the std underlying implementation of the MaybeFut type as a reference.

fn get_tokio_ref(&self) -> Option<&Self::TokioImpl>

Safely unwraps the tokio underlying implementation of the MaybeFut type as a reference.

fn get_std_mut(&mut self) -> Option<&mut Self::StdImpl>

Safely unwraps the std underlying implementation of the MaybeFut type as a mutable reference.

fn get_tokio_mut(&mut self) -> Option<&mut Self::TokioImpl>

Safely unwraps the tokio underlying implementation of the MaybeFut type as a mutable reference.