Struct `AbortHandle`

pub struct AbortHandle { /* private fields */ }

An owned permission to abort a spawned task, without awaiting its completion.

Unlike a JoinHandle, an AbortHandle does not represent the permission to await the task's completion, only to terminate it.

The task may be aborted by calling the AbortHandle::abort method. Dropping an AbortHandle releases the permission to terminate the task --- it does not abort the task.

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.

Implementations

`impl AbortHandle`

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.

If the task was already cancelled, such as by JoinHandle::abort, this method will do nothing.

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.

fn is_finished(&self) -> bool

Checks if the task associated with this AbortHandle 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.

fn id(&self) -> Id

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

Trait Implementations

`impl Clone for AbortHandle`

fn clone(&self) -> Self: Returns a cloned AbortHandle that can be used to remotely abort this task.

`impl Debug for AbortHandle`

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

`impl Drop for AbortHandle`

fn drop(&mut self)

`impl RefUnwindSafe for AbortHandle`

`impl Send for AbortHandle`

`impl Sync for AbortHandle`

`impl UnwindSafe for AbortHandle`

Auto Trait Implementations

`impl Freeze for AbortHandle`

`impl Unpin for AbortHandle`

`impl UnsafeUnpin for AbortHandle`

Blanket Implementations

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

`impl<T> CloneToUninit for AbortHandle where T: Clone,`

unsafe fn clone_to_uninit(&self, dest: *mut u8)

`impl<T> From<T> for AbortHandle`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for AbortHandle where T: Clone,`

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

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

fn into(self) -> U

Calls U::from(self).

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

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

type Error = never;
fn try_from(value: U) -> Result<T, never>

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

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