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);

Implementations

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>