Struct async_task::FallibleTask
source · pub struct FallibleTask<T, M = ()> { /* private fields */ }
Expand description
A spawned task with a fallible response.
This type behaves like Task
, however it produces an Option<T>
when
polled and will return None
if the executor dropped its
Runnable
without being run.
This can be useful to avoid the panic produced when polling the Task
future if the executor dropped its Runnable
.
Implementations§
source§impl<T, M> FallibleTask<T, M>
impl<T, M> FallibleTask<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;
}
})
.fallible()
.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;
}
})
.fallible();
// 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 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.