Struct async_global_executor::Task

#[must_use = "tasks get canceled when dropped, use `.detach()` to run them in the background"]
pub struct Task<T> { /* fields omitted */ }

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>

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();

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;
});

Trait Implementations

impl<T> Debug for Task<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Drop for Task<T>

pub fn drop(&mut self)

Executes the destructor for this type.

impl<T> Future for Task<T>

type Output = T

The type of value produced on completion.

pub fn poll(
    self: Pin<&mut Task<T>>,
    cx: &mut Context<'_>
) -> Poll<<Task<T> as Future>::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<T> RefUnwindSafe for Task<T>

impl<T> Send for Task<T> where
    T: Send, 

impl<T> Sync for Task<T>

impl<T> Unpin for Task<T>

impl<T> UnwindSafe for Task<T>