Struct fast_async_mutex::rwlock_ordered::OrderedRwLock

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

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>

pub 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,