Struct async_global_executor::Task

pub struct Task<T> { /* private fields */ }

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

pub fn fallible(self) -> FallibleTask<T>

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

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.

Trait Implementations

impl<T> Debug for Task<T>

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

Formats the value using the given formatter.

impl<T> Drop for Task<T>

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.

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>