Struct async_task::Runnable

source ·
pub struct Runnable { /* private fields */ }
Expand description

A handle to a runnable task.

Every spawned task has a single Runnable handle, which only exists when the task is scheduled for running.

Method run() polls the task’s future once. Then, the Runnable vanishes and only reappears when its Waker wakes the task, thus scheduling it to be run again.

Dropping a Runnable cancels the task, which means its future won’t be polled again, and awaiting the Task after that will result in a panic.

Examples

use async_task::Runnable;
use once_cell::sync::Lazy;
use std::{panic, thread};

// A simple executor.
static QUEUE: Lazy<flume::Sender<Runnable>> = Lazy::new(|| {
    let (sender, receiver) = flume::unbounded::<Runnable>();
    thread::spawn(|| {
        for runnable in receiver {
            let _ignore_panic = panic::catch_unwind(|| runnable.run());
        }
    });
    sender
});

// Create a task with a simple future.
let schedule = |runnable| QUEUE.send(runnable).unwrap();
let (runnable, task) = async_task::spawn(async { 1 + 2 }, schedule);

// Schedule the task and await its output.
runnable.schedule();
assert_eq!(smol::future::block_on(task), 3);

Implementations§

source§

impl Runnable

source

pub fn schedule(self)

Schedules the task.

This is a convenience method that passes the Runnable to the schedule function.

Examples
// A function that schedules the task when it gets woken up.
let (s, r) = flume::unbounded();
let schedule = move |runnable| s.send(runnable).unwrap();

// Create a task with a simple future and the schedule function.
let (runnable, task) = async_task::spawn(async {}, schedule);

// Schedule the task.
assert_eq!(r.len(), 0);
runnable.schedule();
assert_eq!(r.len(), 1);
source

pub fn run(self) -> bool

Runs the task by polling its future.

Returns true if the task was woken while running, in which case the Runnable gets rescheduled at the end of this method invocation. Otherwise, returns false and the Runnable vanishes until the task is woken. The return value is just a hint: true usually indicates that the task has yielded, i.e. it woke itself and then gave the control back to the executor.

If the Task handle was dropped or if cancel() was called, then this method simply destroys the task.

If the polled future panics, this method propagates the panic, and awaiting the Task after that will also result in a panic.

Examples
// A function that schedules the task when it gets woken up.
let (s, r) = flume::unbounded();
let schedule = move |runnable| s.send(runnable).unwrap();

// Create a task with a simple future and the schedule function.
let (runnable, task) = async_task::spawn(async { 1 + 2 }, schedule);

// Run the task and check its output.
runnable.run();
assert_eq!(smol::future::block_on(task), 3);
source

pub fn waker(&self) -> Waker

Returns a waker associated with this task.

Examples
use smol::future;

// A function that schedules the task when it gets woken up.
let (s, r) = flume::unbounded();
let schedule = move |runnable| s.send(runnable).unwrap();

// Create a task with a simple future and the schedule function.
let (runnable, task) = async_task::spawn(future::pending::<()>(), schedule);

// Take a waker and run the task.
let waker = runnable.waker();
runnable.run();

// Reschedule the task by waking it.
assert_eq!(r.len(), 0);
waker.wake();
assert_eq!(r.len(), 1);

Trait Implementations§

source§

impl Debug for Runnable

source§

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

Formats the value using the given formatter. Read more
source§

impl Drop for Runnable

source§

fn drop(&mut self)

Executes the destructor for this type. Read more
source§

impl RefUnwindSafe for Runnable

source§

impl Send for Runnable

source§

impl Sync for Runnable

source§

impl UnwindSafe for Runnable

Auto Trait Implementations§

§

impl Unpin for Runnable

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.