Struct CancellationToken 

pub struct CancellationToken { /* private fields */ }

A token which can be used to signal a cancellation request to one or more tasks.

Tasks can call CancellationToken::cancelled() in order to obtain a Future which will be resolved when cancellation is requested.

Cancellation can be requested through the CancellationToken::cancel method.

Examples

use tokio::select;
use tokio_util::sync::CancellationToken;

#[tokio::main]
async fn main() {
    let token = CancellationToken::new();
    let cloned_token = token.clone();

    let join_handle = tokio::spawn(async move {
        // Wait for either cancellation or a very long time
        select! {
            _ = cloned_token.cancelled() => {
                // The token was cancelled
                5
            }
            _ = tokio::time::sleep(std::time::Duration::from_secs(9999)) => {
                99
            }
        }
    });

    tokio::spawn(async move {
        tokio::time::sleep(std::time::Duration::from_millis(10)).await;
        token.cancel();
    });

    assert_eq!(5, join_handle.await.unwrap());
}

Implementations

impl CancellationToken

pub fn new() -> CancellationToken

Creates a new CancellationToken in the non-cancelled state.

pub fn child_token(&self) -> CancellationToken

Creates a CancellationToken which will get cancelled whenever the current token gets cancelled. Unlike a cloned CancellationToken, cancelling a child token does not cancel the parent token.

If the current token is already cancelled, the child token will get returned in cancelled state.

Examples

use tokio::select;
use tokio_util::sync::CancellationToken;

#[tokio::main]
async fn main() {
    let token = CancellationToken::new();
    let child_token = token.child_token();

    let join_handle = tokio::spawn(async move {
        // Wait for either cancellation or a very long time
        select! {
            _ = child_token.cancelled() => {
                // The token was cancelled
                5
            }
            _ = tokio::time::sleep(std::time::Duration::from_secs(9999)) => {
                99
            }
        }
    });

    tokio::spawn(async move {
        tokio::time::sleep(std::time::Duration::from_millis(10)).await;
        token.cancel();
    });

    assert_eq!(5, join_handle.await.unwrap());
}

pub fn cancel(&self)

Cancel the CancellationToken and all child tokens which had been derived from it.

This will wake up all tasks which are waiting for cancellation.

Be aware that cancellation is not an atomic operation. It is possible for another thread running in parallel with a call to cancel to first receive true from is_cancelled on one child node, and then receive false from is_cancelled on another child node. However, once the call to cancel returns, all child nodes have been fully cancelled.

pub fn is_cancelled(&self) -> bool

Returns true if the CancellationToken is cancelled.

pub fn cancelled(&self) -> WaitForCancellationFuture<'_>

Returns a Future that gets fulfilled when cancellation is requested.

Equivalent to:

async fn cancelled(&self);

The future will complete immediately if the token is already cancelled when this method is called.

Cancellation safety

This method is cancel safe.

pub fn cancelled_owned(self) -> WaitForCancellationFutureOwned

Returns a Future that gets fulfilled when cancellation is requested.

Equivalent to:

async fn cancelled_owned(self);

The future will complete immediately if the token is already cancelled when this method is called.

The function takes self by value and returns a future that owns the token.

Cancellation safety

This method is cancel safe.

pub fn drop_guard(self) -> DropGuard

Creates a [DropGuard] for this token.

Returned guard will cancel this token (and all its children) on drop unless disarmed.

pub fn drop_guard_ref(&self) -> DropGuardRef<'_>

Creates a [DropGuardRef] for this token.

Returned guard will cancel this token (and all its children) on drop unless disarmed.

pub async fn run_until_cancelled<F>( &self, fut: F, ) -> Option<<F as Future>::Output>

where F: Future,

Runs a future to completion and returns its result wrapped inside of an Option unless the CancellationToken is cancelled. In that case the function returns None and the future gets dropped.

Fairness

Calling this on an already-cancelled token directly returns None. For all subsequent polls, in case of concurrent completion and cancellation, this is biased towards the future completion.

Cancellation safety

This method is only cancel safe if fut is cancel safe.

pub async fn run_until_cancelled_owned<F>( self, fut: F, ) -> Option<<F as Future>::Output>

where F: Future,

Runs a future to completion and returns its result wrapped inside of an Option unless the CancellationToken is cancelled. In that case the function returns None and the future gets dropped.

The function takes self by value and returns a future that owns the token.

Fairness

Calling this on an already-cancelled token directly returns None. For all subsequent polls, in case of concurrent completion and cancellation, this is biased towards the future completion.

Cancellation safety

This method is only cancel safe if fut is cancel safe.

Trait Implementations

impl Clone for CancellationToken

fn clone(&self) -> CancellationToken

Creates a clone of the CancellationToken which will get cancelled whenever the current token gets cancelled, and vice versa.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CancellationToken

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

Formats the value using the given formatter.

impl Default for CancellationToken

fn default() -> CancellationToken

Returns the “default value” for a type.

impl Drop for CancellationToken

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Eq for CancellationToken

impl Hash for CancellationToken

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CancellationToken

fn eq(&self, other: &CancellationToken) -> bool

Checks if two tokens are equal in terms of their cancellation operation.

Two tokens are considered equal if cancelling one will always also cancel the other and vice versa. This is only true for cloned tokens and not for tokens in a parent-child relationship.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl RefUnwindSafe for CancellationToken

impl UnwindSafe for CancellationToken