Struct fast_async_mutex::mutex_unordered::UnorderedMutex

pub struct UnorderedMutex<T: ?Sized> { /* fields omitted */ }

An async unordered mutex. It will be works with any async runtime in Rust, it may be a tokio, smol, async-std and etc..

The main difference with the standard Mutex is unordered mutex will not check an ordering of blocking. This way is much faster, but there are some risks what someone mutex lock will be executed much later.

Implementations

impl<T> UnorderedMutex<T>

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

Create a new UnorderedMutex

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

Acquires the mutex.

Returns a guard that releases the mutex and wake the next locker when dropped.

Examples

use fast_async_mutex::mutex_unordered::UnorderedMutex;

#[tokio::main]
async fn main() {
    let mutex = UnorderedMutex::new(10);
    let guard = mutex.lock().await;
    assert_eq!(*guard, 10);
}

pub fn lock_owned(self: &Arc<Self>) -> UnorderedMutexOwnedGuardFuture<T>

Acquires the mutex.

Returns a guard that releases the mutex and wake the next locker when dropped. UnorderedMutexOwnedGuardFuture have a 'static lifetime, but requires the Arc<Mutex<T>> type

Examples

use fast_async_mutex::mutex_unordered::UnorderedMutex;
use std::sync::Arc;
#[tokio::main]
async fn main() {
    let mutex = Arc::new(UnorderedMutex::new(10));
    let guard = mutex.lock_owned().await;
    assert_eq!(*guard, 10);
}

Trait Implementations

impl<T: Debug> Debug for UnorderedMutex<T>

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

Formats the value using the given formatter.

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

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