Aller au contenu

Annuler du travail

Guide pratique1 min de lecture
Modifier cette page

Vous arrêterez du travail qui n’est plus désiré — recherches abandonnées, panneaux fermés, polls dépassés — en utilisant la boîte à outils d’annulation de Quoin, qui se comporte identiquement sur les cinq adaptateurs.

Prérequis : familiarité avec le lancement de tâches (Charger des données asynchrones).

CancellationToken est clonable et bon marché. Le motif le plus direct le vérifie dans une boucle :

let token = CancellationToken::new();
executor.spawn({
let token = token.clone();
async move {
while !token.is_cancelled() {
do_work().await;
}
cleanup().await;
}
});
// Plus tard, depuis une autre tâche ou un événement UI :
token.cancel();

L’annulation est coopérative : rien ne préempte votre future. Il s’arrête à son prochain point de suspension, donc les longs calculs entre .await la retardent.

token.cancelled() renvoie un future qui se résout quand le jeton se déclenche ; into_cancelled() en donne une variante possédée. Utilisez-les pour sélectionner entre complétion et arrêt :

tokio::select! {
result = work() => handle(result),
_ = token.cancelled() => shutdown().await,
}

run_until_cancelled se résout avec Some(output) quand le future enveloppé se termine d’abord, ou None quand le jeton gagne :

let value = token.run_until_cancelled(work()).await;
match value {
Some(result) => apply(result),
None => /* annulé */,
}

Les écrans de longue durée créent des jetons enfants qui s’annulent avec leur parent mais s’annulent aussi indépendamment :

let parent = CancellationToken::new();
let per_request = parent.child_token(); // s'annule avec le parent
// Annuler per_request laisse le parent intact.
// Annuler parent annule aussi per_request.

Cela modélise les durées de vie UI : un jeton parent par vue, un enfant par requête en vol.

guard() renvoie une garde RAII qui annule le jeton à l’abandon — le motif « annuler quand cette portée se termine » :

let token = CancellationToken::new();
let _guard = token.guard(); // token.cancel() s'exécute quand _guard est abandonné

Détacher ou abandonner — connaissez la différence

Section intitulée « Détacher ou abandonner — connaissez la différence »

Abandonner un handle de join annule la tâche ; c’est la concurrence structurée par défaut. Quand vous voulez vraiment du fire-and-forget, appelez explicitement detach() pour que la tâche s’exécute jusqu’à complétion :

let handle = executor.spawn(log_flusher());
handle.detach(); // survit ; drop(handle) l'aurait annulée