Comment fermer correctement les threads dans le programme Golang

Lors de l'écriture de programmes Golang, il est très courant d'utiliser la programmation simultanée. Le mécanisme goroutine de Golang permet aux développeurs de créer facilement des programmes simultanés, mais si goroutine est mal utilisé, cela entraînera des problèmes tels que des fuites de mémoire et un gaspillage de ressources dans le programme. Par conséquent, fermer correctement goroutine est un moyen nécessaire pour garantir la stabilité du programme.

Cet article expliquera comment fermer correctement goroutine dans le programme Golang.

Comprendre goroutine

Dans Golang, goroutine est un thread léger qui s'exécute sur le thread du système d'exploitation et peut être planifié sur différents threads à tout moment. Par rapport aux threads traditionnels, les goroutines sont plus légères et nécessitent moins de frais de création et de destruction.

Dans Golang, nous pouvons démarrer une goroutine via le mot-clé go, par exemple :

go func() {
    // do something
}()

Le cycle de vie d'une goroutine démarrée de cette manière est contrôlé par le système d'exécution de Golang. Lorsque la tâche de la goroutine est terminée, le garbage collector récupérera automatiquement l'espace mémoire qu'il occupait.

Fermer la goroutine immédiatement

Parfois, nous devons fermer la goroutine immédiatement sans attendre qu'elle se termine, par exemple :

func task() {
    for {
        // do something
    }
}

func main() {
    go task()

    // do other things

    // 关闭task
    // ???
}

Dans le code ci-dessus, nous démarrons une goroutine qui exécute une tâche, mais lorsque le programme doit se terminer, nous espérons pouvoir fermer la goroutine immédiatement pour éviter les fuites de ressources.

Étant donné que la goroutine de Golang ne fournit pas de méthode directe pour la fermer, nous devons effectuer nous-mêmes certains traitements. Une approche courante consiste à utiliser des canaux pour contrôler l’arrêt des goroutines.

Dans la fonction tâche, nous pouvons recevoir un canal en paramètre et envoyer un signal au canal pour indiquer la fermeture de la goroutine. Par exemple :

func task(quit chan bool) {
    for {
        select {
        case <- quit:
            return
        default:
            // do something
        }
    }
}

func main() {
    quit := make(chan bool)
    go task(quit)

    // do other things

    // 关闭task
    quit <- true
}

Dans le code ci-dessus, nous utilisons le mécanisme de sélection dans la fonction de tâche pour attendre Lorsque le signal de fermeture du canal de sortie est reçu, la fonction se terminera immédiatement. Dans la fonction principale, nous créons un canal de sortie et le transmettons en paramètre à la fonction de tâche. Lorsque nous devons fermer la goroutine, envoyez simplement une vraie valeur au canal de sortie.

Arrêter gracieusement la goroutine

Dans le processus de développement réel, nous devons non seulement nous assurer que la goroutine est arrêtée immédiatement, mais également nous assurer que la goroutine peut être arrêtée correctement, c'est-à-dire qu'elle peut terminer les tâches en cours d'exécution avant de s'arrêter. Par exemple :

func task() {
    for {
        // do something
    }
}

func main() {
    quit := make(chan bool)
    go func() {
        for {
            select {
            case <- quit:
                // 执行清理操作
                // ...

                // 退出goroutine
                return
            default:
                // do something
            }
        }
    }()

    // do other things

    // 关闭task
    quit <- true
}

Dans le code ci-dessus, nous démarrons une goroutine, qui écoute le signal de fermeture du canal de sortie via le mécanisme de sélection. Lorsqu'un signal de fermeture est reçu, il effectue des opérations de nettoyage telles que la fermeture des fichiers ouverts, la fermeture des connexions à la base de données, etc. Enfin, il quitte la goroutine, garantissant ainsi que la goroutine s'arrête correctement.

Mécanisme sync.WaitGroup

En plus d'utiliser des canaux pour contrôler la fermeture des goroutines, Golang fournit également le mécanisme sync.WaitGroup pour assurer l'ordre d'exécution et l'ordre de fermeture des goroutines. Par exemple :

func task(wg *sync.WaitGroup) {
    defer wg.Done()

    for {
        // do something
    }
}

func main() {
    var wg sync.WaitGroup

    wg.Add(1)
    go task(&wg)

    // do other things

    // 关闭task
    wg.Wait()
}

Dans le code ci-dessus, nous créons une variable de type sync.WaitGroup et utilisons la méthode Add pour augmenter le compteur de la goroutine. Dans la fonction de tâche, nous utilisons l'instruction defer pour garantir que la méthode Done est appelée une fois la tâche terminée, décrémentant la valeur du compteur. Enfin, utilisez la méthode Wait dans la fonction principale pour attendre que toutes les goroutines terminent leurs tâches.

Utilisez le mécanisme sync.WaitGroup pour arrêter gracieusement goroutine, en vous assurant que toutes les tâches peuvent être terminées avant de quitter.

Résumé

Dans les programmes Golang, fermer correctement la goroutine est un moyen nécessaire pour assurer la stabilité du programme. Grâce au canal ou au mécanisme sync.WaitGroup, nous pouvons contrôler l'ordre de fermeture de goroutine pour garantir que toutes les tâches peuvent être terminées avant de quitter. Lorsqu'ils utilisent goroutine, les développeurs doivent prêter attention aux problèmes tels que les fuites de mémoire et le gaspillage de ressources pour garantir la robustesse et l'efficacité du programme.

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!