Comment fermer goroutine dans golang (trois méthodes)

La goroutine de Golang est l'un de ses puissants mécanismes de concurrence. Les avantages des goroutines sont qu’ils sont légers, efficaces et faciles à créer et à contrôler. Mais en même temps, comment arrêter raisonnablement goroutine est une question très importante.

Pourquoi devrions-nous fermer goroutine ?

La création de goroutines est très simple, mais une utilisation déraisonnable entraînera un gaspillage de ressources, en particulier pour les goroutines de longue durée. Si une goroutine continue de s'exécuter jusqu'à la fin du programme, les ressources système seront occupées, ce qui peut provoquer un crash du programme et affecter les performances du système.

Donc, nous devons fermer la goroutine. Habituellement, les raisons pour lesquelles la goroutine doit être fermée sont :

1. La goroutine doit être fermée à la fin du programme.
2. goroutine doit être fermé après l'exécution pour éviter de gaspiller les ressources du système.
3. Vous devez fermer la goroutine lorsqu'une erreur se produit.

Comment fermer goroutine ?

Le langage GO fournit plusieurs mécanismes pour fermer la goroutine :

1. Utiliser le canal

Vous pouvez utiliser le canal pour fermer la goroutine. Créez un canal et lorsque la goroutine doit être fermée, envoyez des données au canal. La goroutine peut se fermer normalement après avoir lu les données. Par exemple :

func worker(stopCh chan struct{}) {
    for {
        select {
            // do something...
            case <-stopCh:
                return
        }
    }
}

stopCh := make(chan struct{})
go worker(stopCh)

// 关闭 goroutine
close(stopCh)

2. Use context

le package context fournit une manière plus élégante de fermer goroutine. Vous pouvez créer un context.Context et utiliser la fonction WithCancel ou WithTimeout pour annuler le contexte lorsque cela est nécessaire pour fermer la goroutine. Par exemple :

func worker(ctx context.Context) {
    for {
        select {
            // do something...
            case <-ctx.Done():
                return
        }
    }
}

ctx, cancel := context.WithCancel(context.Background())
go worker(ctx)

// 关闭 goroutine
cancel()

3. Utilisez sync.WaitGroup

Le package de synchronisation fournit WaitGroup, qui peut attendre la fin de goroutine. Vous pouvez ajouter une méthode Done qui est appelée à la fin de l'exécution de la goroutine. Si toutes les goroutines ont fini de s'exécuter, vous pouvez utiliser Wait pour bloquer l'attente. Par exemple :

func worker(wg *sync.WaitGroup) {
    defer wg.Done()
    // do something...
}

var wg sync.WaitGroup
wg.Add(1)
go worker(&wg)

// 等待 goroutine 执行结束
wg.Wait()

Remarques sur la fermeture de la goroutine

1. Ne fermez pas la goroutine directement

Normalement, ne fermez pas la goroutine directement, sinon des problèmes tels que des fuites de ressources et des conditions de concurrence peuvent survenir. Vous devez utiliser un canal, un contexte ou WaitGroup pour fermer la goroutine.

2. Concevez une goroutine pour qu'elle puisse être fermée

Lors de la conception d'une goroutine, il est préférable de la concevoir pour qu'elle puisse être fermée. Si une goroutine de longue durée est conçue pour ne pas pouvoir être fermée, elle risque de ne pas pouvoir être fermée, ce qui entraînerait des problèmes. Soyez donc conscient de cela lorsque vous écrivez du code et utilisez des goroutines.

3. Utilisez les ressources système avec prudence

Les ressources système sont limitées et trop de goroutines peuvent occuper trop de ressources système, affectant ainsi les performances du système. Par conséquent, lorsque vous utilisez des goroutines, veillez à utiliser les ressources système avec précaution et à vous assurer qu'elles sont correctement libérées.

Résumé

goroutine est un point fort de Golang car il est léger, efficace et facile à utiliser. Cependant, cette fonctionnalité doit également être utilisée avec prudence. Fermer correctement goroutine est une compétence qui doit être maîtrisée dans le développement Golang. Nous pouvons utiliser des mécanismes tels que le canal, le contexte ou WaitGroup pour fermer goroutine afin d'éviter les fuites de ressources et d'autres problèmes.

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!