Struct piper::Lock

pub struct Lock<T>(_);

An asynchronous lock.

This type is similar to [std::sync::Mutex], except locking is an asynchronous operation.

Note that [Lock] by itself acts like an [Arc] in the sense that cloning it returns just another reference to the same lock.

Furthermore, [LockGuard] is not tied to [Lock] by a lifetime, so you can keep guards for as long as you want. This is useful when you want to spawn a task and move a guard into its future.

Examples

use piper::Lock;
use smol::Task;

let lock = Lock::new(0);
let mut tasks = vec![];

for _ in 0..10 {
    let lock = lock.clone();
    tasks.push(Task::spawn(async move { *lock.lock().await += 1 }));
}

for task in tasks {
    task.await;
}
assert_eq!(*lock.lock().await, 10);

Methods

impl<T> Lock<T>

pub fn new(data: T) -> Lock<T>

Creates a new async lock.

Examples

use piper::Lock;

let lock = Lock::new(0);

pub async fn lock<'_>(&'_ self) -> LockGuard<T>

Acquires the lock.

Returns a guard that releases the lock when dropped.

Examples

use piper::Lock;

let lock = Lock::new(10);
let guard = lock.lock().await;
assert_eq!(*guard, 10);

pub fn try_lock(&self) -> Option<LockGuard<T>>

Attempts to acquire the lock.

If the lock could not be acquired at this time, then [None] is returned. Otherwise, a guard is returned that releases the lock when dropped.

Examples

use piper::Lock;

let lock = Lock::new(10);
if let Some(guard) = lock.try_lock() {
    assert_eq!(*guard, 10);
}

Trait Implementations

impl<T> Clone for Lock<T>

fn clone(&self) -> Lock<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Lock<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Lock<T>

fn default() -> Lock<T>

Returns the "default value" for a type.

impl<T> From<T> for Lock<T>

fn from(val: T) -> Lock<T>

Performs the conversion.

impl<T: Send> Send for Lock<T>

impl<T: Send> Sync for Lock<T>