Comment arrêter la goroutine dans Golang (quatre méthodes)

Golang est un langage conçu pour créer une programmation hautement concurrente et efficace. Il fournit un mécanisme goroutine pratique et efficace, qui peut considérablement améliorer l'efficacité et les performances d'exécution du programme. Cependant, lorsque nous utilisons la goroutine, nous devons prêter attention à certaines choses, comme par exemple comment empêcher la goroutine de s'exécuter. Ce qui suit se concentrera sur la façon d’arrêter goroutine.

Les bases de Goroutine

Avant de comprendre comment arrêter la goroutine, nous devons d'abord comprendre les connaissances de base de la goroutine. Goroutine est une implémentation de threads légers dans le langage Golang et peut s'exécuter sur un ou plusieurs threads. Il est géré par le système d'exécution Go et constitue une unité d'exécution indépendante et légère. Différent des threads traditionnels, goroutine est automatiquement planifié par le système d'exécution Go lors de son exécution, et son modèle de planification est également très efficace. Il peut non seulement bien prendre en charge une concurrence élevée, mais également tirer pleinement parti des processeurs multicœurs.

Comment créer une goroutine

Dans le langage Go, nous pouvons créer une goroutine des deux manières courantes suivantes :

1. En utilisant le mot-clé go

go func() {
    //goroutine运行的代码
}()

2. En utilisant le mot-clé go et le nom de la fonction

func myFunc() {
    //goroutine运行的代码
}

go myFunc()

Comment pour arrêter goroutine

L'arrêt de goroutine est un problème plus compliqué, car goroutine ne fournit pas de méthodes explicites de terminaison et de suspension lors de l'exécution. En effet, l'un des objectifs de conception du langage Go est d'empêcher les goroutines d'être bloquées pendant leur exécution. Nous avons donc besoin de techniques spéciales pour les arrêter.

En langage Go, nous avons les quatre façons suivantes d'arrêter la goroutine :

1. Utiliser le canal

L'utilisation du canal est l'un des moyens les plus simples et les plus sûrs d'arrêter la goroutine. Nous pouvons créer un canal de type booléen. Lorsque nous devons arrêter la goroutine, nous envoyons un signal à ce canal. La goroutine peut sortir normalement après avoir reçu le signal.

func worker(stopChan chan bool) {
    for {
        select {
        case <-stopChan:
            fmt.Println("worker stopped")
            return
        default:
            fmt.Println("worker is running")
            time.Sleep(time.Second)
        }
    }
}

func main() {
    stopChan := make(chan bool)
    go worker(stopChan)
    time.Sleep(3 * time.Second)
    stopChan <- true
    time.Sleep(time.Second)
}

2. Utilisation du contexte

Dans Go1.7, le package de contexte a été ajouté à la bibliothèque standard, fournissant une nouvelle méthode de suspension et d'annulation des goroutines. Nous pouvons transmettre un paramètre de contexte dans chaque goroutine, puis effectuer une opération d'annulation sur cette variable de contexte lorsque nous devons arrêter la goroutine.

func worker(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("worker stopped")
            return
        default:
            fmt.Println("worker is running")
            time.Sleep(time.Second)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    go worker(ctx)
    time.Sleep(3 * time.Second)
    cancel()
    time.Sleep(time.Second)
}

3. Utilisez Mutex et WaitGroup

pour contrôler l'arrêt de goroutine via des variables partagées. Cette méthode nécessite l'utilisation de Mutex et WaitGroup dans le package de synchronisation. Mutex est utilisé pour protéger la lecture et l'écriture de variables partagées, et WaitGroup est utilisé pour attendre la fin de toutes les goroutines.

var wg sync.WaitGroup
var stop bool
var mutex sync.Mutex

func worker() {
    defer wg.Done()
    for {
        mutex.Lock()
        if stop {
            mutex.Unlock()
            fmt.Println("worker stopped")
            return
        }
        fmt.Println("worker is running")
        mutex.Unlock()
        time.Sleep(time.Second)
    }
}

func main() {
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go worker()
    }
    time.Sleep(3 * time.Second)
    mutex.Lock()
    stop = true
    mutex.Unlock()
    wg.Wait()
    time.Sleep(time.Second)
}

4. Utilisez le package d'exécution

La méthode d'utilisation du package d'exécution est un peu plus gênante dans le code exécuté par la goroutine, vous devez vérifier régulièrement les variables globales, puis lorsque vous devez arrêter la goroutine. , utilisez la fonction du package d'exécution pour forcer sa résiliation.

var stop bool

func worker() {
    for {
        if stop {
            fmt.Println("worker stopped")
            return
        }
        fmt.Println("worker is running")
        time.Sleep(time.Second)
    }
}

func main() {
    go worker()
    time.Sleep(3 * time.Second)
    stop = true
    time.Sleep(time.Second)
    runtime.Goexit() //退出当前运行的goroutine
}

Résumé

L'utilisation de goroutine peut grandement améliorer les performances de simultanéité du programme, mais contrôler le fonctionnement de goroutine est également extrêmement important. Comment arrêter goroutine gracieusement est devenu un problème auquel nous devons faire face. Les quatre méthodes ci-dessus ont leurs propres avantages et scénarios applicables, et vous devez choisir la méthode la plus appropriée en fonction de la situation spécifique.

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!