Struct async_weighted_semaphore::SemaphoreGuardArc

#[must_use]pub struct SemaphoreGuardArc { /* fields omitted */ }

A guard returned by Semaphore::acquire_arc that will call Semaphore::release when it is dropped (falls out of scope). Can be sent between threads.

Implementations

impl SemaphoreGuardArc

pub fn new(semaphore: Arc<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: &Arc<Semaphore>,
                 sender: &Sender<T>,
                 message: T
        ) -> Result<(), SendError<T>>{
    match semaphore.acquire_arc(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 Debug for SemaphoreGuardArc

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

Formats the value using the given formatter.

impl Drop for SemaphoreGuardArc

fn drop(&mut self)

Executes the destructor for this type.