Struct async_weighted_semaphore::SemaphoreGuard

#[must_use]pub struct SemaphoreGuard<'a> { /* fields omitted */ }

A guard returned by Semaphore::acquire that will call Semaphore::release when it is dropped (falls out of scope).

Examples

use async_weighted_semaphore::{Semaphore, SemaphoreGuard};
let semaphore = Semaphore::new(1);
let guard: SemaphoreGuard = semaphore.acquire(1).await.unwrap();

Implementations

impl<'a> SemaphoreGuard<'a>

pub fn new(semaphore: &'a Semaphore, amount: usize) -> Self

pub fn forget(self) -> usize

Drop the guard without calling Semaphore::release. This is useful when releases don't correspond one-to-one with acquires or it's difficult to send the guard to the releaser.

Examples

use async_channel::{Sender, SendError};
// Limit size of a producer-consumer queue. Receivers may wait for any number of items
// to be available.
async fn send<T>(semaphore: &Semaphore,
                 sender: &Sender<T>,
                 message: T
        ) -> Result<(), SendError<T>>{
    match semaphore.acquire(1).await {
        // A semaphore can be poisoned to prevent deadlock when a channel closes.
        Err(PoisonError) => Err(SendError(message)),
        Ok(guard) => {
            sender.send(message).await?;
            guard.forget();
            Ok(())
        }
    }
}

Trait Implementations

impl<'a> Debug for SemaphoreGuard<'a>

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

Formats the value using the given formatter.

impl<'a> Drop for SemaphoreGuard<'a>

fn drop(&mut self)

Executes the destructor for this type.