Struct async_executor::StaticExecutor
source · pub struct StaticExecutor { /* private fields */ }static only.Expand description
A static-lifetimed async Executor.
This is primarily intended to be used in static variables, or types intended to be used, or can be created in non-static
contexts via Executor::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 StaticExecutor::tick or
StaticExecutor::run will cause the all spawned tasks to permanently leak. Any
tasks at the time will not be cancelled.
Implementations§
source§impl StaticExecutor
impl StaticExecutor
sourcepub const fn new() -> Self
pub const fn new() -> Self
Creates a new StaticExecutor.
§Examples
use async_executor::StaticExecutor;
static EXECUTOR: StaticExecutor = StaticExecutor::new();sourcepub fn spawn<T: Send + 'static>(
&'static self,
future: impl Future<Output = T> + Send + 'static,
) -> Task<T>
pub fn spawn<T: Send + 'static>( &'static self, future: impl Future<Output = T> + Send + 'static, ) -> Task<T>
Spawns a task onto the executor.
Note: unlike Executor::spawn, this function requires being called with a 'static
borrow on the executor.
§Examples
use async_executor::StaticExecutor;
static EXECUTOR: StaticExecutor = StaticExecutor::new();
let task = EXECUTOR.spawn(async {
println!("Hello world");
});sourcepub unsafe fn spawn_scoped<'a, T: Send + 'a>(
&'static self,
future: impl Future<Output = T> + Send + 'a,
) -> Task<T>
pub unsafe fn spawn_scoped<'a, T: Send + 'a>( &'static self, future: impl Future<Output = T> + Send + '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.
sourcepub fn try_tick(&self) -> bool
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::StaticExecutor;
static EXECUTOR: StaticExecutor = StaticExecutor::new();
assert!(!EXECUTOR.try_tick()); // no tasks to run
let task = EXECUTOR.spawn(async {
println!("Hello world");
});
assert!(EXECUTOR.try_tick()); // a task was foundsourcepub async fn tick(&self)
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::StaticExecutor;
use futures_lite::future;
static EXECUTOR: StaticExecutor = StaticExecutor::new();
let task = EXECUTOR.spawn(async {
println!("Hello world");
});
future::block_on(EXECUTOR.tick()); // runs the tasksourcepub async fn run<T>(&self, future: impl Future<Output = T>) -> T
pub async fn run<T>(&self, future: impl Future<Output = T>) -> T
Runs the executor until the given future completes.
§Examples
use async_executor::StaticExecutor;
use futures_lite::future;
static EXECUTOR: StaticExecutor = StaticExecutor::new();
let task = EXECUTOR.spawn(async { 1 + 2 });
let res = future::block_on(EXECUTOR.run(async { task.await * 2 }));
assert_eq!(res, 6);