Comment Go gère-t-il le délai d'attente des Goroutines ?

Question :

Vous créez un outil qui gère plusieurs appels HTTP dans des goroutines simultanées. Pour éviter un scénario d'exécution indéfinie, vous cherchez un moyen d'annuler les goroutines après un laps de temps spécifique.

Solution :

Alors que l'approche de création d'une goroutine pour dormir pendant une durée spécifiée et envoyer un message de diffusion pour annuler les autres goroutines semble logique, il semble y avoir un problème avec l'exécution des goroutines dans ce cas scénario.

Pour relever ce défi, envisagez de tirer parti du package contextuel dans Go. Il offre un moyen efficace de gérer les délais d'attente et l'annulation de contexte pour les goroutines.

Extrait de code :

Voici un exemple utilisant le package de contexte pour la gestion des délais d'attente des goroutines :

package main

import (
    "context"
    "fmt"
    "time"
)

func test(ctx context.Context) {
    t := time.Now()

    select {
    case <-time.After(1 * time.Second):
        fmt.Println("overslept")
    case <-ctx.Done():
        fmt.Println("cancelled")
    }
    fmt.Println("used:", time.Since(t))
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)

    go test(ctx)

    // cancel context after 30 milliseconds
    time.Sleep(30 * time.Millisecond)
    cancel()
}

Ce code crée un contexte avec un délai d'expiration de 50 millisecondes. Une goroutine est ensuite lancée pour exécuter la fonction de test, en passant le contexte. Dans la fonction de test, une instruction select attend que le délai d'attente se produise ou que le contexte soit annulé. Après 30 millisecondes, le contexte est annulé, ce qui entraîne la fin de la goroutine et l'impression « annulé ».