Struct async_executor::Executor
source · pub struct Executor<'a> { /* private fields */ }
Expand description
An async executor.
Examples
A multi-threaded executor:
use async_channel::unbounded;
use async_executor::Executor;
use easy_parallel::Parallel;
use futures_lite::future;
let ex = Executor::new();
let (signal, shutdown) = unbounded::<()>();
Parallel::new()
// Run four executor threads.
.each(0..4, |_| future::block_on(ex.run(shutdown.recv())))
// Run the main future on the current thread.
.finish(|| future::block_on(async {
println!("Hello world!");
drop(signal);
}));
Implementations§
source§impl<'a> Executor<'a>
impl<'a> Executor<'a>
sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns true
if there are no unfinished tasks.
Examples
use async_executor::Executor;
let ex = Executor::new();
assert!(ex.is_empty());
let task = ex.spawn(async {
println!("Hello world");
});
assert!(!ex.is_empty());
assert!(ex.try_tick());
assert!(ex.is_empty());
sourcepub fn spawn<T: Send + 'a>(
&self,
future: impl Future<Output = T> + Send + 'a
) -> Task<T>
pub fn spawn<T: Send + 'a>( &self, future: impl Future<Output = T> + Send + 'a ) -> Task<T>
Spawns a task onto the executor.
Examples
use async_executor::Executor;
let ex = Executor::new();
let task = ex.spawn(async {
println!("Hello world");
});
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::Executor;
let ex = Executor::new();
assert!(!ex.try_tick()); // no tasks to run
let task = ex.spawn(async {
println!("Hello world");
});
assert!(ex.try_tick()); // a task was found
sourcepub 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::Executor;
use futures_lite::future;
let ex = Executor::new();
let task = ex.spawn(async {
println!("Hello world");
});
future::block_on(ex.tick()); // runs the task
sourcepub 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::Executor;
use futures_lite::future;
let ex = Executor::new();
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 RefUnwindSafe for Executor<'_>
impl Send for Executor<'_>
impl Sync for Executor<'_>
impl UnwindSafe for Executor<'_>
Auto Trait Implementations§
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more