Struct async_executor::StaticLocalExecutor

pub struct StaticLocalExecutor { /* private fields */ }

Available on crate feature static only.

A static async LocalExecutor created from LocalExecutor::leak.

This is primarily intended to be used in thread_local variables, or can be created in non-static contexts via LocalExecutor::leak.

Spawning, running, and finishing tasks are optimized with the assumption that the executor will never be Drop’ed. A static executor may require signficantly less overhead in both single-threaded and mulitthreaded use cases.

As this type does not implement Drop, losing the handle to the executor or failing to consistently drive the executor with StaticLocalExecutor::tick or StaticLocalExecutor::run will cause the all spawned tasks to permanently leak. Any tasks at the time will not be cancelled.

Implementations

impl StaticLocalExecutor

pub const fn new() -> Self

Creates a new StaticLocalExecutor.

Examples

use async_executor::StaticLocalExecutor;

thread_local! {
    static EXECUTOR: StaticLocalExecutor = StaticLocalExecutor::new();
}

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

Spawns a task onto the executor.

Note: unlike LocalExecutor::spawn, this function requires being called with a 'static borrow on the executor.

Examples

use async_executor::LocalExecutor;

let ex = LocalExecutor::new().leak();

let task = ex.spawn(async {
    println!("Hello world");
});

pub unsafe fn spawn_scoped<'a, T: 'a>( &'static self, future: impl Future<Output = T> + 'a, ) -> Task<T>

Spawns a non-'static task onto the executor.

Safety

The caller must ensure that the returned task terminates or is cancelled before the end of ’a.

pub fn try_tick(&self) -> bool

Attempts to run a task if at least one is scheduled.

Running a scheduled task means simply polling its future once.

Examples

use async_executor::LocalExecutor;

let ex = LocalExecutor::new().leak();
assert!(!ex.try_tick()); // no tasks to run

let task = ex.spawn(async {
    println!("Hello world");
});
assert!(ex.try_tick()); // a task was found

pub async fn tick(&self)

Runs a single task.

Running a task means simply polling its future once.

If no tasks are scheduled when this method is called, it will wait until one is scheduled.

Examples

use async_executor::LocalExecutor;
use futures_lite::future;

let ex = LocalExecutor::new().leak();

let task = ex.spawn(async {
    println!("Hello world");
});
future::block_on(ex.tick()); // runs the task

pub async fn run<T>(&self, future: impl Future<Output = T>) -> T

Runs the executor until the given future completes.

Examples

use async_executor::LocalExecutor;
use futures_lite::future;

let ex = LocalExecutor::new().leak();

let task = ex.spawn(async { 1 + 2 });
let res = future::block_on(ex.run(async { task.await * 2 }));

assert_eq!(res, 6);

Trait Implementations

impl Debug for StaticLocalExecutor

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

Formats the value using the given formatter.

impl Default for StaticLocalExecutor

fn default() -> Self

Returns the “default value” for a type.

impl RefUnwindSafe for StaticLocalExecutor

impl UnwindSafe for StaticLocalExecutor