Struct fast_async_mutex::mutex_ordered::OrderedMutex

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

The Ordered Mutex has its mechanism of locking order when you have concurrent access to data. It will work well when you needed step by step data locking like sending UDP packages in a specific order.

The main difference with the standard Mutex is ordered mutex will check an ordering of blocking. This way has some guaranties of mutex execution order, but it's a little bit slowly than original mutex.

Implementations

impl<T> OrderedMutex<T>

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

Create a new OrderedMutex

impl<T: ?Sized> OrderedMutex<T>

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

Acquires the mutex.

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

Examples

use fast_async_mutex::mutex_ordered::OrderedMutex;

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

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

Acquires the mutex.

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

Examples

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

Trait Implementations

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

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

Formats the value using the given formatter.

impl<T: ?Sized> Send for OrderedMutex<T> where
    T: Send, 

impl<T: ?Sized> Sync for OrderedMutex<T> where
    T: Send + Sync,