0Pricing
Go Academy · Leçon

Détection des fuites et annulation

Garantir la sortie des goroutines et empêcher les fuites

Détection des fuites et annulation est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Qu’est-ce qu’une fuite de gouroutines ?

Une fuite de gouroutines se produit lorsqu’une gouroutine démarre sans jamais se terminer. Les gouroutines qui fuient s’accumulent au fil du temps et consomment de la mémoire de pile ainsi que du CPU, jusqu’à l’arrêt forcé du processus.

Fuite courante : réception bloquée sur un canal

Une gouroutine qui attend une réception sur un canal auquel aucune valeur n’est jamais envoyée reste bloquée indéfiniment :

go func() {
    v := <-ch // leaks if no sender and ch is never closed
    use(v)
}()

Fuite courante&nbsp;: aucun signal Done

Une gouroutine dans une boucle for sans condition de sortie ni canal Done s’exécute indéfiniment :

go func() {
    for {
        work()
        // no exit condition — leaks
    }
}()

Détecter les fuites avec goleak

go.uber.org/goleak vérifie qu’aucune gouroutine ne fuit à la fin d’une vérification :

func TestMyFunc(t *testing.T) {
    defer goleak.VerifyNone(t)
    myFunc() // should not leak goroutines
}

Le contexte comme solution

La manière idiomatique d’arrêter les gouroutines qui s’exécutent longtemps consiste à utiliser un contexte. Transmettez ctx à la gouroutine et sélectionnez le cas ctx.Done().

go func(ctx context.Context) {
    for {
        select {
        case work := <-workCh:
            process(work)
        case <-ctx.Done():
            return // clean exit
        }
    }
}(ctx)

Modèle du canal Done

Pour les cas plus simples qui n’utilisent pas de contexte, utilisez un canal Done dédié. Fermez-le pour diffuser le signal d’arrêt à toutes les gouroutines qui le lisent.

done := make(chan struct{})
go func() {
    select {
    case v := <-data: use(v)
    case <-done: return
    }
}()
close(done) // stops goroutine

Détecter les fuites avec runtime

Affichez le nombre de gouroutines afin de détecter son augmentation lors de l’exécution :

fmt.Println("goroutines:", runtime.NumGoroutine())

Gouroutines des serveurs HTTP

net/http gère automatiquement les gouroutines associées à chaque requête et les nettoie lorsque la requête se termine. Toutefois, les gestionnaires qui lancent des gouroutines sans les nettoyer peuvent toujours provoquer des fuites.

Tester l’absence de fuites

Exécutez votre suite de tests avec goleak en utilisant TestMain ou un defer par test. Toute gouroutine qui n’est pas terminée après le corps du test entraîne l’échec du test.

func TestMain(m *testing.M) {
    goleak.VerifyTestMain(m)
}

Fuites liées à time.After

time.After dans une instruction select placée dans une boucle crée un nouveau minuteur à chaque itération. Celui-ci ne peut pas être récupéré par le GC avant son déclenchement. Remplacez-le par time.NewTimer et Reset.

Fuite due à une gouroutine renvoyant une erreur

Si une gouroutine est censée envoyer un résultat sur un canal mais retourne prématurément à cause d’une erreur sans rien envoyer, la gouroutine consommatrice reste bloquée indéfiniment. Envoyez toujours une valeur ou fermez le canal sur tous les chemins d’exécution.

Vérification rapide

Quelle est la manière la plus idiomatique d’arrêter une gouroutine qui s’exécute longtemps en Go ?

Récapitulatif&nbsp;: détection des fuites et annulation

Points essentiels :

  • Les fuites de gouroutines s’accumulent ; surveillez-les avec runtime.NumGoroutine()
  • goleak détecte automatiquement les fuites de gouroutines dans les tests
  • Donnez toujours aux gouroutines un chemin de sortie : contexte, canal Done ou entrée fermée
  • time.After dans les boucles provoque des fuites de minuteurs ; utilisez NewTimer+Reset

Questions Fréquemment Posées

La leçon « Détection des fuites et annulation » est-elle gratuite ?

Oui — le texte complet de « Détection des fuites et annulation » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Détection des fuites et annulation » ?

Garantir la sortie des goroutines et empêcher les fuites Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Détection des fuites et annulation » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Modèles de pipeline et d’étapes
  2. errgroup pour la gestion concurrente des erreurs
  3. Modèle du sémaphore
  4. Détection des fuites et annulation
← Retour à Go Academy