Struct Task 

pub struct Task {
    pub pool: Vec<UnboundedSender<AsyncTask>>,
    pub counter: Arc<AtomicUsize>,
    pub shutdown: Arc<AtomicBool>,
    pub notifies: Vec<Arc<Notify>>,
}

Task manager for handling async tasks across worker threads.

This structure manages a pool of task senders distributed across multiple worker threads, enabling efficient round-robin task scheduling with event-driven wake-up mechanism.

Fields

pool: Vec<UnboundedSender<AsyncTask>>

Pool of unbounded senders for distributing tasks to worker threads.

counter: Arc<AtomicUsize>

Atomic counter for round-robin task distribution across workers.

shutdown: Arc<AtomicBool>

Flag indicating whether the task pool should shut down.

notifies: Vec<Arc<Notify>>

Notification handles for precise wake-up of specific workers.

Implementations

impl Task

pub fn new(worker_count: usize) -> Self

Creates a new Task instance.

Arguments

• usize: The number of worker threads to spawn.

Returns

• Self: The new instance.

pub fn try_spawn_local<F>(&self, index_opt: Option<usize>, hook: F) -> bool

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

Attempts to spawn a server task onto the global server task pool.

This function sends the task to one of the worker threads in the pool. The worker is selected using a round-robin algorithm based on an atomic counter, or a forced index if provided.

Arguments

• Option<usize>: An optional index to force selection of a specific worker. If None, the worker is selected using round-robin distribution.
• Future<Output = ()> + Send + 'static: The future to spawn on the task pool.

Returns

• bool: true if the task was successfully sent, false otherwise.

pub fn shutdown(&self)

Shuts down the task pool.

This function sets the shutdown flag and wakes all waiting worker threads, causing them to exit their processing loops.

impl Task

pub fn get_pool(&self) -> &Vec<UnboundedSender<AsyncTask>>

pub fn get_mut_pool(&mut self) -> &mut Vec<UnboundedSender<AsyncTask>>

pub fn set_pool(&mut self, val: Vec<UnboundedSender<AsyncTask>>) -> &mut Self

pub fn get_counter(&self) -> &Arc<AtomicUsize>

pub fn get_mut_counter(&mut self) -> &mut Arc<AtomicUsize>

pub fn set_counter(&mut self, val: Arc<AtomicUsize>) -> &mut Self

pub fn get_shutdown(&self) -> &Arc<AtomicBool>

pub fn get_mut_shutdown(&mut self) -> &mut Arc<AtomicBool>

pub fn set_shutdown(&mut self, val: Arc<AtomicBool>) -> &mut Self

pub fn get_notifies(&self) -> &Vec<Arc<Notify>>

pub fn get_mut_notifies(&mut self) -> &mut Vec<Arc<Notify>>

pub fn set_notifies(&mut self, val: Vec<Arc<Notify>>) -> &mut Self

Trait Implementations

impl Clone for Task

fn clone(&self) -> Task

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Task

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

Formats the value using the given formatter.

impl Default for Task

Creates a default Task instance.

fn default() -> Self

Creates a default Task instance.

Returns

• Self: The default instance.

impl Display for Task

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

Formats the value using the given formatter.

impl Drop for Task

Automatically shuts down the task pool when the Task instance is dropped.

fn drop(&mut self)

Shuts down the task pool when the Task instance is dropped.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.