Struct abort_on_drop::ChildTask

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

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.

use tokio::time;

#[tokio::main]
async fn main() {
   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());

Trait Implementations

impl<T: Debug> Debug for ChildTask<T>

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

Formats the value using the given formatter.

impl<T> Deref for ChildTask<T>

type Target = JoinHandle<T>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> Drop for ChildTask<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> From<JoinHandle<T>> for ChildTask<T>

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

Converts to this type from the input type.

impl<T> Future for ChildTask<T>

type Output = <JoinHandle<T> as Future>::Output

The type of value produced on completion.

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

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