Struct AsyncPoolBuilder

pub struct AsyncPoolBuilder<S = DefaultSpawn> { /* private fields */ }

AsyncPoolBuilder provides a flexible way to configure and build an AsyncPool for executing asynchronous tasks concurrently on dedicated threads.

This builder enables you to customize the number of threads, concurrency limits, thread naming, and panic handling strategies.

Implementations

impl AsyncPoolBuilder<DefaultSpawn>

pub fn new(runtime: Handle) -> AsyncPoolBuilder<DefaultSpawn>

Initializes a new AsyncPoolBuilder with default settings.

The builder is tied to the provided [tokio::runtime::Handle] and prepares to configure an AsyncPool.

impl<S> AsyncPoolBuilder<S>

where S: ThreadSpawn,

pub fn pool_name(self, pool_name: &'static str) -> Self

Specifies a custom name for this pool.

pub fn thread_name<F>(self, thread_name: F) -> Self

where F: FnMut(usize) -> String + 'static,

Specifies a custom naming convention for threads in the AsyncPool.

The provided closure receives the thread’s index and returns a name, which can be useful for debugging and logging.

pub fn thread_panic_handler<F>(self, panic_handler: F) -> Self

where F: Fn(Box<dyn Any + Send>) + Send + Sync + 'static,

Sets a custom panic handler for threads in the AsyncPool.

If a thread panics, the provided handler will be invoked so that you can perform custom error handling or cleanup.

pub fn task_panic_handler<F>(self, panic_handler: F) -> Self

where F: Fn(Box<dyn Any + Send>) + Send + Sync + 'static,

Sets a custom panic handler for tasks executed by the AsyncPool.

This handler is used to manage panics that occur during task execution, allowing for graceful error handling.

pub fn spawn_handler<F>( self, spawn_handler: F, ) -> AsyncPoolBuilder<CustomSpawn<F>>

where F: FnMut(Thread) -> Result<()>,

Configures a custom thread spawning procedure for the AsyncPool.

This method allows you to adjust thread settings (e.g. naming, stack size) before thread creation, making it possible to apply application-specific configurations.

pub fn num_threads(self, num_threads: usize) -> Self

Sets the number of worker threads for the AsyncPool.

This determines how many dedicated threads will be available for running tasks concurrently.

pub fn max_concurrency(self, max_concurrency: usize) -> Self

Sets the maximum number of concurrent tasks per thread in the AsyncPool.

This controls how many futures can be polled simultaneously on each worker thread.

pub fn build<F>(self) -> Result<AsyncPool<F>, Error>

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

Constructs an AsyncPool based on the configured settings.

Finalizing the builder sets up dedicated worker threads and configures the executor to enforce the specified concurrency limits.