Comment gérer l’annulation de tâches simultanées en langage Go ?

Comment gérer l'annulation de tâches simultanées en langage Go ?

En tant que langage de programmation simultanée, le langage Go fournit de riches fonctionnalités de programmation simultanée, telles que goroutine et canal, ce qui rend très pratique la gestion de tâches simultanées. Cependant, lorsqu'il s'agit d'annuler des tâches simultanées, nous avons également besoin de mécanismes spéciaux pour garantir la sortie en toute sécurité des tâches. Cet article expliquera comment gérer l'annulation de tâches simultanées dans le langage Go et donnera des exemples de code spécifiques.

En langage Go, nous utilisons généralement la goroutine pour effectuer des tâches simultanées. Goroutine est un thread léger qui peut effectuer plusieurs tâches simultanément pour utiliser pleinement les ressources informatiques sur les processeurs multicœurs. Nous pouvons créer une goroutine via le mot-clé go, par exemple :

go func() {
  // 并发任务的逻辑代码
}()

Lorsque nous créons plusieurs goroutines pour exécuter des tâches simultanément, nous devons parfois annuler activement l'exécution d'une ou plusieurs tâches lorsqu'une certaine condition est remplie. Afin de réaliser cette fonction, le langage Go fournit un mécanisme intégré : le contexte. Le package de contexte fournit un mécanisme d'annulation pour transmettre les requêtes et nous aide à suivre et à annuler les opérations dans les goroutines. Voici un exemple de code sur la façon d'utiliser le contexte pour annuler une tâche :

package main

import (
    "context"
    "fmt"
    "time"
)

func worker(ctx context.Context) {
    for {
        select {
        default:
            // 执行任务的逻辑代码
            fmt.Println("正在执行任务...")
            time.Sleep(500 * time.Millisecond)
        case <-ctx.Done():
            // 收到取消信号，退出goroutine
            fmt.Println("任务被取消")
            return
        }
    }
}

func main() {
    // 创建一个context对象和cancel函数
    ctx, cancel := context.WithCancel(context.Background())

    // 启动多个goroutine执行任务
    for i := 0; i < 5; i++ {
        go worker(ctx)
    }

    // 延迟5秒后，取消任务
    time.Sleep(5 * time.Second)
    cancel()

    // 等待所有goroutine退出
    time.Sleep(1 * time.Second)
    fmt.Println("所有任务已完成")
}

Dans l'exemple de code ci-dessus, nous utilisons la fonction context.WithCancel pour créer un objet de contexte annulable et envoyer un signal d'annulation via la fonction d'annulation. Dans la fonction Worker, nous utilisons l'instruction select pour exécuter des tâches et annuler la surveillance. Si un signal d'annulation est reçu, nous quittons la goroutine. En appelant la fonction d'annulation, nous pouvons propager le signal d'annulation à toutes les goroutines de travail.

En exécutant le code ci-dessus, nous pouvons voir le résultat comme suit :

正在执行任务...
正在执行任务...
正在执行任务...
任务被取消
任务被取消
任务被取消
任务被取消
任务被取消
所有任务已完成

Comme le montre le résultat, lorsque nous appelons la fonction d'annulation, toutes les goroutines de travail ont reçu le signal d'annulation et sont sorties en toute sécurité.

Pour résumer, le langage Go offre un moyen élégant de gérer l'annulation de tâches simultanées via le mécanisme contextuel. Il suffit d'écouter le message Done du contexte pendant l'exécution de la tâche. Une fois le signal d'annulation reçu, nous pouvons quitter la goroutine en toute sécurité. Ce mécanisme rend l'annulation de tâches concurrentes plus simple et plus fiable, et évite d'introduire des conditions de concurrence inutiles dans l'application.

Ce qui précède est une introduction et un exemple de code sur la façon de gérer l'annulation de tâches simultanées en langage Go. J'espère que ça aide.

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!