Struct async_global_executor::Task
source · pub struct Task<T, M = ()> { /* private fields */ }Expand description
A spawned task.
A Task can be awaited to retrieve the output of its future.
Dropping a Task cancels it, which means its future won’t be polled again. To drop the
Task handle without canceling it, use detach() instead. To cancel a
task gracefully and wait until it is fully destroyed, use the cancel()
method.
Note that canceling a task actually wakes it and reschedules one last time. Then, the executor
can destroy the task by simply dropping its Runnable or by invoking
run().
§Examples
use smol::{future, Executor};
use std::thread;
let ex = Executor::new();
// Spawn a future onto the executor.
let task = ex.spawn(async {
println!("Hello from a task!");
1 + 2
});
// Run an executor thread.
thread::spawn(move || future::block_on(ex.run(future::pending::<()>())));
// Wait for the task's output.
assert_eq!(future::block_on(task), 3);Implementations§
source§impl<T, M> Task<T, M>
impl<T, M> Task<T, M>
sourcepub fn detach(self)
pub fn detach(self)
Detaches the task to let it keep running in the background.
§Examples
use smol::{Executor, Timer};
use std::time::Duration;
let ex = Executor::new();
// Spawn a deamon future.
ex.spawn(async {
loop {
println!("I'm a daemon task looping forever.");
Timer::after(Duration::from_secs(1)).await;
}
})
.detach();sourcepub async fn cancel(self) -> Option<T>
pub async fn cancel(self) -> Option<T>
Cancels the task and waits for it to stop running.
Returns the task’s output if it was completed just before it got canceled, or None if
it didn’t complete.
While it’s possible to simply drop the Task to cancel it, this is a cleaner way of
canceling because it also waits for the task to stop running.
§Examples
use smol::{future, Executor, Timer};
use std::thread;
use std::time::Duration;
let ex = Executor::new();
// Spawn a deamon future.
let task = ex.spawn(async {
loop {
println!("Even though I'm in an infinite loop, you can still cancel me!");
Timer::after(Duration::from_secs(1)).await;
}
});
// Run an executor thread.
thread::spawn(move || future::block_on(ex.run(future::pending::<()>())));
future::block_on(async {
Timer::after(Duration::from_secs(3)).await;
task.cancel().await;
});sourcepub fn fallible(self) -> FallibleTask<T, M>
pub fn fallible(self) -> FallibleTask<T, M>
Converts this task into a FallibleTask.
Like Task, a fallible task will poll the task’s output until it is
completed or cancelled due to its Runnable being
dropped without being run. Resolves to the task’s output when completed,
or None if it didn’t complete.
§Examples
use smol::{future, Executor};
use std::thread;
let ex = Executor::new();
// Spawn a future onto the executor.
let task = ex.spawn(async {
println!("Hello from a task!");
1 + 2
})
.fallible();
// Run an executor thread.
thread::spawn(move || future::block_on(ex.run(future::pending::<()>())));
// Wait for the task's output.
assert_eq!(future::block_on(task), Some(3));use smol::future;
// Schedule function which drops the runnable without running it.
let schedule = move |runnable| drop(runnable);
// Create a task with the future and the schedule function.
let (runnable, task) = async_task::spawn(async {
println!("Hello from a task!");
1 + 2
}, schedule);
runnable.schedule();
// Wait for the task's output.
assert_eq!(future::block_on(task.fallible()), None);sourcepub fn is_finished(&self) -> bool
pub fn is_finished(&self) -> bool
Returns true if the current task is finished.
Note that in a multithreaded environment, this task can change finish immediately after calling this function.