Struct TaskPool 

pub struct TaskPool { /* private fields */ }

A concurrent task execution pool with semaphore-based concurrency control.

TaskPool manages the execution of asynchronous tasks with a configurable limit on the number of concurrent tasks. It provides cancellation support and automatic resource cleanup.

Thread Safety

TaskPool is thread-safe and can be cloned to share across multiple contexts. All clones share the same underlying semaphore and cancellation token.

Implementations

impl TaskPool

pub fn new(n_tasks: usize) -> TaskPool

Creates a new TaskPool with the specified concurrency limit.

Arguments

• n_tasks - Maximum number of tasks that can execute concurrently

Examples

use quetty_server::taskpool::TaskPool;

let pool = TaskPool::new(5); // Allow up to 5 concurrent tasks

pub fn execute<F, T>(&self, func: F)

where F: Future<Output = T> + Send + 'static, T: Send,

Executes a future in the task pool with concurrency control.

The task will wait for a semaphore permit before executing. If the pool is cancelled while the task is running, it will be interrupted gracefully.

Type Parameters

• F - Future type that implements Send and has a static lifetime
• T - Output type of the future that implements Send

Arguments

• func - The async function/future to execute

Examples

use quetty_server::taskpool::TaskPool;

async fn example() {
    let pool = TaskPool::new(3);

    pool.execute(async {
        println!("Task is running");
        // Do some work
    });
}

pub fn cancel_all(&self)

Cancels all currently running and queued tasks.

This sends a cancellation signal to all tasks. Tasks that are currently executing will be interrupted at their next cancellation check point. Tasks waiting for permits will be cancelled before they start.

Examples

use quetty_server::taskpool::TaskPool;

async fn example() {
    let pool = TaskPool::new(3);

    // Start some tasks
    for i in 0..10 {
        pool.execute(async move {
            println!("Task {}", i);
        });
    }

    // Cancel all tasks
    pool.cancel_all();
}

pub fn close(&self)

Closes the task pool to prevent new tasks from starting.

This closes the underlying semaphore, which prevents new tasks from acquiring permits. Tasks that are already running will continue to completion.

Examples

use quetty_server::taskpool::TaskPool;

async fn example() {
    let pool = TaskPool::new(3);

    // Use the pool...

    // Close it to prevent new tasks
    pool.close();
}

Trait Implementations

impl Clone for TaskPool

fn clone(&self) -> TaskPool

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Drop for TaskPool

fn drop(&mut self)

Automatically closes the semaphore when the last TaskPool reference is dropped.

This ensures that resources are properly cleaned up when the task pool is no longer needed. The semaphore is only closed when this is the last remaining reference to prevent premature shutdown.