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

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

En programmation concurrente, les dépendances entre les tâches sont un problème courant. Lorsqu'il existe des dépendances entre plusieurs tâches, nous devons nous assurer qu'elles sont exécutées dans un certain ordre pour éviter les courses de données et les résultats incertains. En langage Go, nous pouvons utiliser certaines techniques et outils pour résoudre ce problème.

Une méthode courante consiste à utiliser un sémaphore (Semaphore), qui peut également être implémenté à l'aide d'un mutex (Mutex) et d'une variable de condition (Cond). Ci-dessous, nous présenterons comment utiliser les verrous mutex et les variables de condition pour implémenter des dépendances entre les tâches et fournirons des exemples de code spécifiques.

Tout d'abord, nous devons définir une structure de tâches, qui contient des informations et des dépendances liées aux tâches. Le code spécifique est le suivant :

type Task struct {
    id         int           // 任务ID
    dependsOn  []*Task       // 依赖的任务
    completed  bool          // 任务是否已完成
    mutex      sync.Mutex    // 互斥锁
    cond       *sync.Cond    // 条件变量
}

func NewTask(id int) *Task {
    task := &Task{
        id:        id,
        completed: false,
    }
    task.cond = sync.NewCond(&task.mutex)
    return task
}

Ensuite, nous pouvons définir une fonction d'exécution de tâche, qui attendra que les tâches dépendantes soient terminées avant de s'exécuter. Le code spécifique est le suivant :

func (t *Task) Run() {
    for _, task := range t.dependsOn {
        task.Wait() // 等待依赖的任务完成
    }

    // 执行任务的逻辑
    fmt.Println("Task", t.id, "is running...")

    // 标记任务为已完成
    t.mutex.Lock()
    t.completed = true
    t.cond.Broadcast() // 通知其他等待的任务
    t.mutex.Unlock()
}

De plus, nous devons également définir. une fonction qui attend que la tâche soit terminée, cette méthode se bloquera lorsque la tâche n'est pas terminée jusqu'à ce qu'elle revienne une fois la tâche terminée. Le code spécifique est le suivant :

func (t *Task) Wait() {
    t.mutex.Lock()
    defer t.mutex.Unlock()

    for !t.completed {
        t.cond.Wait()
    }
}

Enfin, nous pouvons créer plusieurs tâches et définir leurs dépendances pour une exécution simultanée. Le code spécifique est le suivant :

func main() {
    // 创建任务
    task1 := NewTask(1)
    task2 := NewTask(2)
    task3 := NewTask(3)

    // 设置任务的依赖关系
    task2.dependsOn = []*Task{task1}
    task3.dependsOn = []*Task{task2}

    // 启动任务
    go task1.Run()
    go task2.Run()
    go task3.Run()

    // 阻塞等待任务完成
    task3.Wait()

    fmt.Println("All tasks completed.")
}

Dans le code ci-dessus, nous créons trois tâches, définissons les dépendances entre elles, puis démarrons les tâches simultanément, et enfin bloquons et attendons que la dernière tâche se termine. Lorsque la tâche est terminée, nous imprimons "Toutes les tâches terminées.".

En utilisant des verrous mutex et des variables de condition, nous pouvons résoudre les problèmes de dépendance de tâches simultanées dans le langage Go. Cette approche garantit que les tâches sont exécutées dans le bon ordre, évitant ainsi les courses de données et les résultats incertains. Dans le même temps, l’utilisation de verrous mutex et de variables de condition peut améliorer la flexibilité du programme et les performances de concurrence.

Bien sûr, en plus des mutex et des variables de condition, le langage Go fournit également d'autres primitives de concurrence, telles que Channel et WaitGroup, etc. Vous pouvez choisir la solution appropriée en fonction des besoins réels.

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!