Struct fast_async_mutex::rwlock_ordered::OrderedRwLock

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

An async ordered RwLock. It will be work with any async runtime in Rust, it may be a tokio, smol, async-std, etc..

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

The RW Lock mechanism accepts you get shared access to your data without locking. But, when you have often read, writes may wait too long, while reads don't stop. The Ordered RW Lock will be locking all reads, which starting after write and unlocking them only when write will realize. It may be slow down the reads speed, but decrease time to write on systems, where it is critical.

BUT RW Lock has some limitations. You should avoid acquiring the second reading before realizing first inside the one future. Because it can happen that between your readings a write from another thread will acquire the mutex, and you will get a deadlock.

Implementations

impl<T> OrderedRwLock<T>

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

Create a new OrderedRWLock

impl<T: ?Sized> OrderedRwLock<T>

pub fn write(&self) -> OrderedRwLockWriteGuardFuture<'_, T>

Acquires the mutex for are write.

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

Examples

use fast_async_mutex::rwlock_ordered::OrderedRwLock;

#[tokio::main]
async fn main() {
    let mutex = OrderedRwLock::new(10);
    let mut guard = mutex.write().await;
    *guard += 1;
    assert_eq!(*guard, 11);
}

pub fn write_owned(self: &Arc<Self>) -> OrderedRwLockWriteOwnedGuardFuture<T>

Acquires the mutex for are write.

Returns a guard that releases the mutex and wake the next locker when it will be dropped. WriteLockOwnedGuard have a 'static lifetime, but requires the Arc<RWLock<T>> type

Examples

use fast_async_mutex::rwlock_ordered::OrderedRwLock;
use std::sync::Arc;
#[tokio::main]
async fn main() {
    let mutex = Arc::new(OrderedRwLock::new(10));
    let mut guard = mutex.write_owned().await;
    *guard += 1;
    assert_eq!(*guard, 11);
}

pub fn read(&self) -> OrderedRwLockReadGuardFuture<'_, T>

Acquires the mutex for are read.

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

Examples

use fast_async_mutex::rwlock_ordered::OrderedRwLock;

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

pub fn read_owned(self: &Arc<Self>) -> OrderedRwLockReadOwnedGuardFuture<T>

Acquires the mutex for are write.

Returns a guard that releases the mutex and wake the next locker when it will be dropped. WriteLockOwnedGuard have a 'static lifetime, but requires the Arc<RWLock<T>> type

Examples

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

pub fn try_acquire_reader(&self, id: usize) -> bool

Trait Implementations

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

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

Formats the value using the given formatter.

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

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