Struct SemaphoreScheduler 

pub struct SemaphoreScheduler { /* private fields */ }

Semaphore-based task scheduler

Limits concurrent task execution using a tokio::sync::Semaphore. Tasks will wait for an available permit before executing.

Cancellation Behavior

• Respects cancellation tokens before and during permit acquisition
• Once a permit is acquired (via ResourceGuard), always awaits task completion
• Holds the permit until the task completes (regardless of cancellation)
• Tasks handle their own cancellation internally (if created with spawn_cancellable)

This ensures that permits are not leaked when tasks are cancelled, while still allowing cancellable tasks to terminate gracefully on their own.

Example

// Allow up to 5 concurrent tasks
let semaphore = Arc::new(Semaphore::new(5));
let scheduler = SemaphoreScheduler::new(semaphore);

Implementations

impl SemaphoreScheduler

pub fn new(semaphore: Arc<Semaphore>) -> Self

Create a new semaphore scheduler

Arguments

• semaphore - Semaphore to use for concurrency control

pub fn with_permits(permits: usize) -> Arc<Self>

Create a semaphore scheduler with the specified number of permits, returning Arc

pub fn available_permits(&self) -> usize

Get the number of available permits

Trait Implementations

impl ArcPolicy for SemaphoreScheduler

fn new_arc(self) -> Arc<Self>

Create an Arc-wrapped instance of this policy

impl Debug for SemaphoreScheduler

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

Formats the value using the given formatter.

impl TaskScheduler for SemaphoreScheduler

fn acquire_execution_slot<'life0, 'async_trait>( &'life0 self, cancel_token: CancellationToken, ) -> Pin<Box<dyn Future<Output = SchedulingResult<Box<dyn ResourceGuard>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Acquire resources needed for task execution and return a guard