Struct AbortOnDropJoinHandle 

pub struct AbortOnDropJoinHandle<T>(/* private fields */);

Exactly like a [tokio::task::JoinHandle], except that it aborts the task when the handle is dropped.

This behavior makes it easier to tie a worker task to the lifetime of a Resource by keeping this handle owned by the Resource.

Implementations

impl<T> AbortOnDropJoinHandle<T>

pub async fn cancel(self) -> Option<T>

Abort the task and wait for it to finish. Optionally returns the result of the task if it ran to completion prior to being aborted.

Methods from Deref<Target = JoinHandle<T>>

pub fn abort(&self)

Abort the task associated with the handle.

Awaiting a cancelled task might complete as usual if the task was already completed at the time it was cancelled, but most likely it will fail with a cancelled JoinError.

Be aware that tasks spawned using spawn_blocking cannot be aborted because they are not async. If you call abort on a spawn_blocking task, then this will not have any effect, and the task will continue running normally. The exception is if the task has not started running yet; in that case, calling abort may prevent the task from starting.

See also the module level docs for more information on cancellation.

use tokio::time;

let mut handles = Vec::new();

handles.push(tokio::spawn(async {
   time::sleep(time::Duration::from_secs(10)).await;
   true
}));

handles.push(tokio::spawn(async {
   time::sleep(time::Duration::from_secs(10)).await;
   false
}));

for handle in &handles {
    handle.abort();
}

for handle in handles {
    assert!(handle.await.unwrap_err().is_cancelled());
}

pub fn is_finished(&self) -> bool

Checks if the task associated with this JoinHandle has finished.

Please note that this method can return false even if abort has been called on the task. This is because the cancellation process may take some time, and this method does not return true until it has completed.

use tokio::time;

let handle1 = tokio::spawn(async {
    // do some stuff here
});
let handle2 = tokio::spawn(async {
    // do some other stuff here
    time::sleep(time::Duration::from_secs(10)).await;
});
// Wait for the task to finish
handle2.abort();
time::sleep(time::Duration::from_secs(1)).await;
assert!(handle1.is_finished());
assert!(handle2.is_finished());

pub fn abort_handle(&self) -> AbortHandle

Returns a new AbortHandle that can be used to remotely abort this task.

Awaiting a task cancelled by the AbortHandle might complete as usual if the task was already completed at the time it was cancelled, but most likely it will fail with a cancelled JoinError.

use tokio::{time, task};

let mut handles = Vec::new();

handles.push(tokio::spawn(async {
   time::sleep(time::Duration::from_secs(10)).await;
   true
}));

handles.push(tokio::spawn(async {
   time::sleep(time::Duration::from_secs(10)).await;
   false
}));

let abort_handles: Vec<task::AbortHandle> = handles.iter().map(|h| h.abort_handle()).collect();

for handle in abort_handles {
    handle.abort();
}

for handle in handles {
    assert!(handle.await.unwrap_err().is_cancelled());
}

pub fn id(&self) -> Id

Returns a task ID that uniquely identifies this task relative to other currently spawned tasks.

Trait Implementations

impl<T: Debug> Debug for AbortOnDropJoinHandle<T>

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

Formats the value using the given formatter.

impl<T> Deref for AbortOnDropJoinHandle<T>

type Target = JoinHandle<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for AbortOnDropJoinHandle<T>

fn deref_mut(&mut self) -> &mut JoinHandle<T>

Mutably dereferences the value.

impl<T> Drop for AbortOnDropJoinHandle<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> From<JoinHandle<T>> for AbortOnDropJoinHandle<T>

fn from(jh: JoinHandle<T>) -> Self

Converts to this type from the input type.

impl<T> Future for AbortOnDropJoinHandle<T>

type Output = T

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &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.