Struct SemaphorePermit
pub struct SemaphorePermit<'a> { /* private fields */ }
sync only.A permit from the semaphore.
This type is created by the acquire method.
Implementations
impl<'a> SemaphorePermit<'a>
pub fn forget(self)
Forgets the permit without releasing it back to the semaphore. This can be used to reduce the amount of permits available from a semaphore.
Examples
use std::sync::Arc;
use tokio::sync::Semaphore;
let sem = Arc::new(Semaphore::new(10));
{
let permit = sem.try_acquire_many(5).unwrap();
assert_eq!(sem.available_permits(), 5);
permit.forget();
}
// Since we forgot the permit, available permits won't go back to its initial value
// even after the permit is dropped.
assert_eq!(sem.available_permits(), 5);pub fn merge(&mut self, other: Self)
Merge two SemaphorePermit instances together, consuming other without releasing the permits it holds.
Permits held by both self and other are released when self drops.
Panics
This function panics if permits from different Semaphore instances are merged.
Examples
use std::sync::Arc;
use tokio::sync::Semaphore;
let sem = Arc::new(Semaphore::new(10));
let mut permit = sem.try_acquire().unwrap();
for _ in 0..9 {
let _permit = sem.try_acquire().unwrap();
// Merge individual permits into a single one.
permit.merge(_permit)
}
assert_eq!(sem.available_permits(), 0);
// Release all permits in a single batch.
drop(permit);
assert_eq!(sem.available_permits(), 10);pub fn split(&mut self, n: usize) -> Option<Self>
Splits n permits from self and returns a new SemaphorePermit instance that holds n permits.
If there are insufficient permits and it’s not possible to reduce by n, returns None.
Examples
use std::sync::Arc;
use tokio::sync::Semaphore;
let sem = Arc::new(Semaphore::new(3));
let mut p1 = sem.try_acquire_many(3).unwrap();
let p2 = p1.split(1).unwrap();
assert_eq!(p1.num_permits(), 2);
assert_eq!(p2.num_permits(), 1);pub fn num_permits(&self) -> usize
Returns the number of permits held by self.
Trait Implementations
impl<'a> Debug for SemaphorePermit<'a>
impl Drop for SemaphorePermit<'_>
Auto Trait Implementations
impl<'a> !RefUnwindSafe for SemaphorePermit<'a>
impl<'a> !UnwindSafe for SemaphorePermit<'a>
impl<'a> Freeze for SemaphorePermit<'a>
impl<'a> Send for SemaphorePermit<'a>
impl<'a> Sync for SemaphorePermit<'a>
impl<'a> Unpin for SemaphorePermit<'a>
impl<'a> UnsafeUnpin for SemaphorePermit<'a>
Blanket Implementations
impl<T> BorrowMut<T> for Twhere T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
impl<T> Instrument for T
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
impl<T> WithSubscriber for T
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘ
fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ
MIT License
Copyright © Tokio Contributors
https://docs.rs/tokio/1.53.1/tokio/sync/struct.SemaphorePermit.html