Struct tokio::sync::OwnedSemaphorePermit
source · pub struct OwnedSemaphorePermit { /* private fields */ }
Expand description
An owned permit from the semaphore.
This type is created by the acquire_owned
method.
Implementations§
source§impl OwnedSemaphorePermit
impl OwnedSemaphorePermit
sourcepub fn forget(self)
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.clone().try_acquire_many_owned(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);
sourcepub fn merge(&mut self, other: Self)
pub fn merge(&mut self, other: Self)
Merge two OwnedSemaphorePermit
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.clone().try_acquire_owned().unwrap();
for _ in 0..9 {
let _permit = sem.clone().try_acquire_owned().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);
sourcepub fn split(&mut self, n: usize) -> Option<Self>
pub fn split(&mut self, n: usize) -> Option<Self>
Splits n
permits from self
and returns a new OwnedSemaphorePermit
instance that holds n
permits.
If there are insufficient permits and it’s not possible to reduce by n
, returns None
.
§Note
It will clone the owned Arc<Semaphore>
to construct the new instance.
§Examples
use std::sync::Arc;
use tokio::sync::Semaphore;
let sem = Arc::new(Semaphore::new(3));
let mut p1 = sem.try_acquire_many_owned(3).unwrap();
let p2 = p1.split(1).unwrap();
assert_eq!(p1.num_permits(), 2);
assert_eq!(p2.num_permits(), 1);
sourcepub fn semaphore(&self) -> &Arc<Semaphore>
pub fn semaphore(&self) -> &Arc<Semaphore>
Returns the Semaphore
from which this permit was acquired.
sourcepub fn num_permits(&self) -> usize
pub fn num_permits(&self) -> usize
Returns the number of permits held by self
.