Comment arrêter le fil de discussion dans Golang

Dans Golang, nous pouvons créer des threads simultanés via goroutine, et le cycle de vie de ces threads est généralement géré par le système d'exécution de Golang. Cependant, dans certains cas, nous pouvons avoir besoin de contrôler le cycle de vie du thread, comme par exemple arrêter un thread en cours d'exécution après qu'une certaine condition soit remplie. Cet article explique comment arrêter les threads dans Golang.

1. Utiliser les canaux

Dans Golang, les canaux sont un outil très puissant qui peut être utilisé pour la communication et la synchronisation entre les threads. Et les canaux dans Golang sont thread-safe, nous pouvons donc utiliser des canaux pour arrêter les threads.

Tout d'abord, nous définissons un canal d'arrêt :

stopCh := make(chan struct{})

Ensuite, dans notre fil de discussion, nous pouvons envoyer un signal au canal lorsqu'une certaine condition est remplie, indiquant que le fil de discussion en cours doit être arrêté :

select {
case <- stopCh:
    // 收到停止信号，退出线程
    return
default:
    // 正常运行代码
}

Enfin, nous juste Vous devez envoyer un signal à ce canal où vous devez arrêter le fil pour arrêter le fil :

close(stopCh)

2. Utiliser le contexte

Dans les versions après Golang 1.7, le package de contexte est ajouté à la bibliothèque standard, qui fournit A moyen plus flexible de contrôler le cycle de vie des threads.

Nous créons d'abord un contexte :

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

Ensuite, dans notre fil, nous pouvons écouter ce contexte et quitter le fil si un signal d'arrêt est reçu :

for {
    select {
    case <- ctx.Done():
        // 收到停止信号，退出线程
        return
    default:
        // 正常运行代码
    }
}

Enfin, il suffit d'arrêter le fil là où nous en avons besoin , Appelez la fonction d'annulation pour arrêter le thread :

cancel()

3. Utilisez le package de synchronisation

En plus d'utiliser les canaux et le contexte, le package de synchronisation de la bibliothèque standard Golang fournit également un moyen de contrôler le cycle de vie du thread. Nous pouvons utiliser le WaitGroup dans le package de synchronisation pour coordonner l'exécution des threads.

Tout d'abord, nous créons un WaitGroup :

var wg sync.WaitGroup

Ensuite, dans notre thread, nous démarrons une coroutine et exécutons le code et contrôlons son cycle de vie via le compteur WaitGroup :

wg.Add(1)
go func() {
    for {
        select {
        case <- stopCh:
            // 停止信号，清除WaitGroup计数器
            wg.Done()
            return
        default:
            // 正常运行代码
        }
    }
}()

Enfin, nous ne devons nous arrêter que lorsque nous en avons besoin Là où se trouve le thread, attendez simplement que toutes les coroutines se terminent :

close(stopCh)
wg.Wait()

Résumé :

Voici les trois façons d'arrêter les threads dans Golang. Dans différents scénarios, nous pouvons choisir différentes manières d'arrêter les threads selon les besoins. La méthode canal est simple et facile à utiliser, la méthode contextuelle est plus flexible et la méthode sync.WaitGroup peut contrôler le cycle de vie de plusieurs coroutines. En utilisation réelle, nous devons faire un choix en fonction de scénarios d'application spécifiques.

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!