Struct maitake::scheduler::LocalSpawner

pub struct LocalSpawner(/* private fields */);

Available on crate feature alloc only.

A handle to a LocalScheduler that implements Send.

The LocalScheduler and LocalStaticScheduler types are capable of spawning futures which do not implement Send. Because of this, those scheduler types themselves are also !Send and !Sync, as as ticking them from another thread would cause its tasks to be polled from that thread, violating the Send and Sync contracts.

However, tasks which are Send may still be spawned on a !Send scheduler, alongside !Send tasks. Because the scheduler types are !Sync, other threads may not reference them in order to spawn remote tasks on those schedulers. This type is a handle to a !Sync scheduler which can be sent across thread boundaries, as it does not have the capacity to poll tasks or reference the current task.

This type owns a Weak reference to the scheduler. If the LocalScheduler is dropped, any attempts to spawn a task using this handle will return a JoinHandle that fails with a “scheduler shut down” error.

This type is returned by LocalScheduler::spawner.

Implementations

impl LocalSpawner

pub fn spawn<F>(&self, future: F) -> JoinHandle<F::Output>

where F: Future + Send + 'static, F::Output: Send + 'static,

Spawn a task on the LocalScheduler this handle references.

Unlike LocalScheduler::spawn, this method requires that the spawned Future implement Send, as the LocalSpawner type is Send and Sync, and therefore allows tasks to be spawned on a local scheduler from other threads.

This method returns a JoinHandle that can be used to await the task’s output. Dropping the JoinHandle detaches the spawned task, allowing it to run in the background without awaiting its output.

When tasks are spawned on a scheduler, the scheduler must be ticked in order to drive those tasks to completion. See the module-level documentation for more information on implementing a system’s run loop.

pub fn spawn_allocated<F>( &self, task: Box<Task<LocalScheduler, F, BoxStorage>>, ) -> JoinHandle<F::Output>

where F: Future + Send + 'static, F::Output: Send + 'static,

Spawn a pre-allocated task on the LocalScheduler this handle references.

Unlike LocalScheduler::spawn_allocated and LocalStaticScheduler::spawn_allocated, this method requires that the spawned Future implement Send, as the LocalSpawner type is Send and Sync, and therefore allows tasks to be spawned on a local scheduler from other threads.

This method is used to spawn a task that requires some bespoke procedure of allocation, typically of a custom Storage implementor. See the documentation for the Storage trait for more details on using custom task storage.

This method returns a JoinHandle that can be used to await the task’s output. Dropping the JoinHandle detaches the spawned task, allowing it to run in the background without awaiting its output.

When tasks are spawned on a scheduler, the scheduler must be ticked in order to drive those tasks to completion. See the module-level documentation for more information on implementing a system’s run loop.

Trait Implementations

impl Clone for LocalSpawner

fn clone(&self) -> LocalSpawner

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LocalSpawner

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

Formats the value using the given formatter.