pub struct LocalSpawner(/* private fields */);
Expand description
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§
Source§impl LocalSpawner
impl LocalSpawner
Sourcepub fn spawn<F>(&self, future: F) -> JoinHandle<F::Output> ⓘ
pub fn spawn<F>(&self, future: F) -> JoinHandle<F::Output> ⓘ
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.
Sourcepub fn spawn_allocated<F>(
&self,
task: Box<Task<LocalScheduler, F, BoxStorage>>,
) -> JoinHandle<F::Output> ⓘ
pub fn spawn_allocated<F>( &self, task: Box<Task<LocalScheduler, F, BoxStorage>>, ) -> JoinHandle<F::Output> ⓘ
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§
Source§impl Clone for LocalSpawner
impl Clone for LocalSpawner
Source§fn clone(&self) -> LocalSpawner
fn clone(&self) -> LocalSpawner
1.0.0 · Source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read more