Struct JoinHandle

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

An owned permission to join on a task (awaiting its termination).

This can be thought of as the equivalent of std::thread::JoinHandle or tokio::task::JoinHandle for a task that is executed concurrently.

A JoinHandle detaches the associated task when it is dropped, which means that there is no longer any handle to the task, and no way to join on it.

This struct is created by the crate::spawn and crate::spawn_blocking functions.

Examples

Creation from crate::spawn:

let join_handle: async_wasm_task::JoinHandle<_> = async_wasm_task::spawn(async {
    // some work here
});

Creation from crate::spawn_blocking:

let join_handle: async_wasm_task::JoinHandle<_> = async_wasm_task::spawn_blocking(|| {
    // some blocking work here
});

Child being detached and outliving its parent:

let original_task = async_wasm_task::spawn(async {
    let _detached_task = async_wasm_task::spawn(async {
        // Here we sleep to make sure that the first task returns before.
        // Assume that code takes a few seconds to execute here.
        // This will be called, even though the JoinHandle is dropped.
        println!("♫ Still alive ♫");
    });
});

original_task.await.expect("The task being joined has panicked");
println!("Original task is joined.");

Trait Implementations

impl<T> Debug for JoinHandle<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Future for JoinHandle<T>

type Output = Result<T, JoinError>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Self::Output>

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

impl<T: Send> Send for JoinHandle<T>

impl<T: Send> Sync for JoinHandle<T>

impl<T> Unpin for JoinHandle<T>