Comment résoudre le problème de la dépendance des tâches et du graphique de planification des tâches simultanées en langage Go ?

Comment résoudre les problèmes de dépendance des tâches et de graphiques de planification des tâches des tâches simultanées en langage Go ?

Dans le langage Go, l'exécution de tâches de manière simultanée peut améliorer considérablement les performances et l'efficacité du programme. Cependant, lorsqu'il existe des dépendances entre les tâches et doivent être exécutées dans un ordre spécifique, nous devons résoudre le problème des dépendances des tâches et des graphiques de planification des tâches dans les tâches simultanées. Cet article expliquera comment utiliser le langage Go pour résoudre ces problèmes et donnera des exemples de code spécifiques.

Tout d'abord, nous devons définir la structure de la tâche. Chaque tâche doit contenir un identifiant unique, le code logique de la tâche et d'autres tâches dont dépend la tâche. Par exemple :

type Task struct {
    ID         int
    Logic      func()
    Dependency []*Task
}

Ensuite, nous devons créer une fonction qui exécute une tâche et ses tâches dépendantes. Cette fonction doit être appelée de manière récursive en fonction des dépendances de la tâche pour garantir que toutes les tâches dépendantes ont été exécutées avant d'exécuter la tâche en cours. L'exemple de code est le suivant :

func executeTask(task *Task, tasksCompleted *sync.Map) {
    // 检查任务依赖是否已经完成
    for _, dependency := range task.Dependency {
        dependencyID := dependency.ID
        _, dependencyCompleted := tasksCompleted.Load(dependencyID)
        if !dependencyCompleted {
            // 等待依赖的任务完成
            executeTask(dependency, tasksCompleted)
        }
    }

    // 执行当前任务
    task.Logic()

    // 任务完成标记设为true
    tasksCompleted.Store(task.ID, true)
}

Ensuite, nous devons créer l'intégralité du graphique de planification des tâches et exécuter toutes les tâches. Nous pouvons utiliser une carte pour stocker toutes les tâches et utiliser sync.Map pour marquer si la tâche est terminée. L'exemple de code est le suivant :

func main() {
    // 创建所有任务和它们的依赖关系
    task1 := &Task{
        ID:    1,
        Logic: func() { fmt.Println("执行任务1") },
    }
    task2 := &Task{
        ID:         2,
        Logic:      func() { fmt.Println("执行任务2") },
        Dependency: []*Task{task1},
    }
    task3 := &Task{
        ID:         3,
        Logic:      func() { fmt.Println("执行任务3") },
        Dependency: []*Task{task1},
    }
    task4 := &Task{
        ID:         4,
        Logic:      func() { fmt.Println("执行任务4") },
        Dependency: []*Task{task2, task3},
    }

    // 构建任务调度图
    tasks := map[int]*Task{
        1: task1,
        2: task2,
        3: task3,
        4: task4,
    }

    // 执行所有任务
    tasksCompleted := &sync.Map{}
    for _, task := range tasks {
        go executeTask(task, tasksCompleted)
    }

    // 等待所有任务完成
    time.Sleep(time.Second)
}

Grâce aux exemples de code ci-dessus, nous avons résolu avec succès les problèmes de dépendance des tâches et de graphique de planification des tâches des tâches simultanées dans le langage Go. Dans les applications pratiques, des modifications et extensions appropriées peuvent être apportées selon les besoins. Dans le même temps, nous pouvons également constater qu'en organisant raisonnablement les dépendances des tâches et l'exécution simultanée, les performances et l'efficacité du programme peuvent être considérablement améliorées.

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!