Comment résoudre le problème de la surveillance de l'état d'exécution des tâches simultanées en langage Go ?

Dans le langage Go, en raison de sa prise en charge inhérente de la concurrence et du parallélisme, les scénarios impliquent souvent plusieurs tâches exécutées en même temps. Cependant, la surveillance de l'état d'exécution des tâches simultanées est une question très critique. Nous devons garantir la bonne exécution des tâches et être informés de la progression et des résultats des tâches en temps opportun. Cet article expliquera comment résoudre le problème de la surveillance de l'état d'exécution des tâches simultanées dans le langage Go et donnera des exemples de code spécifiques.

En langage Go, nous pouvons implémenter l'exécution simultanée de tâches via goroutine. Chaque tâche peut être représentée par une goroutine et les canaux sont utilisés pour la communication et la synchronisation entre les tâches. Par conséquent, nous pouvons connaître l’état d’exécution de la tâche en surveillant l’état du canal.

Tout d'abord, nous définissons une structure de tâches pour représenter les tâches exécutées simultanément. La structure contient un champ d'entrée pour recevoir les paramètres d'entrée, un champ de sortie pour stocker les résultats de l'exécution de la tâche et un champ terminé pour indiquer si la tâche est terminée.

type Task struct {
    input  interface{}
    output interface{}
    done   chan bool
}

Ensuite, nous définissons une fonction pour effectuer des tâches spécifiques. Lors de l'exécution de la tâche, nous pouvons indiquer la progression de la tâche en écrivant le résultat de la tâche dans le champ de sortie. Lorsque la tâche est terminée, nous écrivons true dans le champ terminé pour indiquer que la tâche est terminée.

func (t *Task) Run() {
    // 执行具体的任务逻辑，将结果写入output字段

    // 标记任务执行完成
    t.done <- true
}

Maintenant, nous pouvons créer un gestionnaire de tâches pour gérer l'exécution des tâches simultanées. Le gestionnaire de tâches est chargé de créer et de démarrer des goroutines pour exécuter des tâches, et d'interroger périodiquement l'état des tâches.

type TaskManager struct {
    tasks []*Task
}

func (tm *TaskManager) RunTasks() {
    // 启动goroutine执行所有任务
    for _, task := range tm.tasks {
        go task.Run()
    }

    // 定期查询任务的状态
    ticker := time.NewTicker(time.Second)
    defer ticker.Stop()

    for range ticker.C {
        allDone := true

        // 查询每个任务的状态
        for _, task := range tm.tasks {
            select {
            case <-task.done:
                // 任务已完成
                fmt.Println("Task completed")
                // 处理任务的结果
                fmt.Println("Task result:", task.output)
            default:
                // 任务未完成
                allDone = false
            }
        }

        // 所有任务都已完成退出循环
        if allDone {
            break
        }
    }
}

Enfin, nous pouvons créer des tâches simultanées dans la fonction principale, les ajouter au gestionnaire de tâches et appeler la méthode RunTasks du gestionnaire de tâches pour exécuter et surveiller l'état d'exécution de la tâche.

func main() {
    task1 := &Task{
        input:  "Task 1 input",
        output: nil,
        done:   make(chan bool),
    }

    task2 := &Task{
        input:  "Task 2 input",
        output: nil,
        done:   make(chan bool),
    }

    taskManager := &TaskManager{
        tasks: []*Task{task1, task2},
    }

    taskManager.RunTasks()
}

Grâce à l'exemple de code ci-dessus, nous pouvons surveiller l'état d'exécution des tâches simultanées. Les résultats d'exécution de la tâche peuvent être traités en fonction des besoins réels, comme la sortie des résultats de la tâche, etc. Parallèlement, nous pouvons également ajuster et optimiser la mise en œuvre du gestionnaire de tâches en fonction de scénarios spécifiques.

Pour résumer, en utilisant les fonctionnalités de goroutine et de canal, nous pouvons facilement surveiller l'état d'exécution des tâches simultanées. Cette méthode nous permet de mieux contrôler l'exécution de la tâche et de connaître la progression et les résultats de la tâche en temps opportun.

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!