Quelques notes sur la fermeture des chaînes en golang

Golang est un langage de programmation efficace en matière de développement qui utilise des coroutines efficaces pour prendre en charge la programmation simultanée. Cependant, comme une coroutine est un thread d’exécution léger, elle est fermée différemment des autres threads. Dans cet article, nous aborderons quelques considérations sur l'arrêt dans Golang.

1. Fermer la chaîne

À Golang, fermer la chaîne est un concept important. Fermer un canal signifie le fermer sans autre envoi de valeurs. La fermeture du canal entraînera la réussite immédiate de toutes les opérations de réception sur le canal, et les opérations de réception renverront les valeurs déjà présentes dans le canal et une valeur nulle une fois que toutes les valeurs auront été reçues.

Par exemple, le code suivant montre comment fermer une chaîne :

package main

import "fmt"

func main() {
    ch := make(chan int)

    go func() {
        for i := 0; i < 10; i++ {
            ch <- i
        }
        close(ch)  // 关闭信道
    }()

    for {
        v, ok := <-ch
        if !ok {
            break  // 信道已关闭
        }
        fmt.Println(v)
    }
}

Il convient de noter que la chaîne ne peut être fermée que par l'expéditeur, pas par le destinataire. Si vous essayez de fermer le canal du récepteur, cela peut provoquer une panique lors de l'exécution.

2. Évitez de tomber dans une impasse

Dans Golang, l'opération d'arrêt peut provoquer la chute de la coroutine dans un état d'impasse. En effet, lorsqu'une coroutine attend un canal fermé, elle attendra indéfiniment. Nous devons donc suivre certaines règles pour éviter que cela ne se produise.

Tout d'abord, nous devons toujours utiliser une boucle for pour recevoir la valeur du canal. De cette façon, lorsque le canal est fermé, la boucle se ferme automatiquement et nous pouvons déterminer si le canal est fermé en vérifiant la deuxième valeur de retour.

Deuxièmement, nous devrions essayer d'éviter d'utiliser des canaux non tamponnés dans les coroutines. En effet, lors de l'utilisation d'un canal sans tampon, l'expéditeur sera bloqué jusqu'à ce que la valeur soit reçue par le destinataire. Ainsi, si nous fermons un canal sans tampon, le récepteur ne recevra jamais la valeur et il n'y aura aucun moyen de quitter la coroutine.

3. La fermeture n'est pas nécessaire

Dans certains cas, la fermeture d'une chaîne n'est pas nécessaire. Par exemple, si nous devons simplement envoyer quelques valeurs dans le canal puis quitter le programme immédiatement, il n'est pas nécessaire de fermer le canal. À la fin du programme, toutes les chaînes non fermées seront automatiquement fermées.

De plus, si notre programme ne contient qu'une seule coroutine, et que le cycle de vie du canal est égal ou inférieur au cycle de vie de la coroutine, il n'est pas nécessaire de fermer le canal. Car à la fin de la coroutine, tous les canaux non fermés seront automatiquement fermés.

4. Utilisez sync.WaitGroup pour attendre la fin de la coroutine

Dans Golang, la programmation simultanée est très courante. Afin de garantir que la coroutine a terminé toutes les opérations, nous pouvons utiliser sync.WaitGroup pour attendre la fin de la coroutine. Lorsque la coroutine est terminée, nous pouvons libérer la coroutine en appelant la méthode sync.WaitGroup.Done().

Voici un exemple montrant comment attendre la fin d'une coroutine à l'aide de sync.WaitGroup :

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    ch := make(chan int)

    for i := 0; i < 2; i++ {
        wg.Add(1)

        go func() {
            defer wg.Done()

            for v := range ch {
                fmt.Println(v)
            }
        }()
    }

    for i := 0; i < 10; i++ {
        ch <- i
    }

    close(ch)

    wg.Wait()
}

Résumé

La fermeture est très importante dans Golang car elle implique un aspect clé de la programmation simultanée. Nous devons faire attention à la façon de fermer correctement un canal et d’éviter les blocages. Nous devons toujours attendre que toutes les coroutines soient terminées et utiliser des outils tels que sync.WaitGroup pour garantir une sortie en toute sécurité des coroutines.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!