Struct BackgroundExecutor 

pub struct BackgroundExecutor { /* private fields */ }

A pointer to the executor that is currently running, for spawning background tasks.

Implementations

impl BackgroundExecutor

BackgroundExecutor lets you run things on background threads. In production this is a thread pool with no ordering guarantees. In tests this is simulated by running tasks one by one in a deterministic (but arbitrary) order controlled by the SEED environment variable.

pub fn spawn<R>( &self, future: impl Future<Output = R> + Send + 'static, ) -> Task<R>

where R: Send + 'static,

Enqueues the given future to be run to completion on a background thread.

pub fn spawn_with_priority<R>( &self, priority: Priority, future: impl Future<Output = R> + Send + 'static, ) -> Task<R>

where R: Send + 'static,

Enqueues the given future to be run to completion on a background thread.

pub async fn await_on_background<R>( &self, future: impl Future<Output = R> + Send, ) -> R

where R: Send,

Enqueues the given future to be run to completion on a background thread and blocking the current task on it.

This allows to spawn background work that borrows from its scope. Note that the supplied future will run to completion before the current task is resumed, even if the current task is slated for cancellation.

pub fn spawn_labeled<R>( &self, label: TaskLabel, future: impl Future<Output = R> + Send + 'static, ) -> Task<R>

where R: Send + 'static,

Enqueues the given future to be run to completion on a background thread. The given label can be used to control the priority of the task in tests.

pub fn block<R>(&self, future: impl Future<Output = R>) -> R

Block the current thread until the given future resolves. Consider using block_with_timeout instead.

pub fn block_with_timeout<Fut: Future>( &self, duration: Duration, future: Fut, ) -> Result<Fut::Output, impl Future<Output = Fut::Output> + use<Fut>>

Block the current thread until the given future resolves or duration has elapsed.

pub async fn scoped<'scope, F>(&self, scheduler: F)

where F: FnOnce(&mut Scope<'scope>),

Scoped lets you start a number of tasks and waits for all of them to complete before returning.

pub async fn scoped_priority<'scope, F>(&self, priority: Priority, scheduler: F)

where F: FnOnce(&mut Scope<'scope>),

Scoped lets you start a number of tasks and waits for all of them to complete before returning.

pub fn now(&self) -> Instant

Get the current time.

Calling this instead of std::time::Instant::now allows the use of fake timers in tests.

pub fn timer(&self, duration: Duration) -> Task<()>

Returns a task that will complete after the given duration. Depending on other concurrent tasks the elapsed duration may be longer than requested.

pub fn num_cpus(&self) -> usize

How many CPUs are available to the dispatcher.

pub fn is_main_thread(&self) -> bool

Whether we’re on the main thread.

Trait Implementations

impl Clone for BackgroundExecutor

fn clone(&self) -> BackgroundExecutor

Returns a duplicate of the value.

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

Performs copy-assignment from source.