Struct async_task::Task [−][src]
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
impl<T> Task<T>
[src]
pub fn detach(self)
[src]
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();
pub async fn cancel(self) -> Option<T>
[src]
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; });
Trait Implementations
impl<T> Debug for Task<T>
[src]
impl<T> Drop for Task<T>
[src]
impl<T> Future for Task<T>
[src]
type Output = T
The type of value produced on completion.
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>
[src]
impl<T> RefUnwindSafe for Task<T>
[src]
impl<T: Send> Send for Task<T>
[src]
impl<T> Sync for Task<T>
[src]
impl<T> Unpin for Task<T>
[src]
impl<T> UnwindSafe for Task<T>
[src]
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<F> IntoFuture for F where
F: Future,
[src]
F: Future,
type Output = <F as Future>::Output
into_future
)The output that the future will produce on completion.
type Future = F
into_future
)Which kind of future are we turning this into?
pub fn into_future(self) -> <F as IntoFuture>::Future
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,