How to solve the problem of concurrent task dependency in Go language?

How to solve the problem of concurrent task dependency in Go language?

In concurrent programming, dependency between tasks is a common problem. When there are dependencies between multiple tasks, we need to ensure that they are executed in a certain order to avoid data races and uncertain results. In Go language, we can use some techniques and tools to solve this problem.

A common method is to use a semaphore (Semaphore), which can also be implemented using a mutex (Mutex) and a condition variable (Cond). Below we will introduce how to use mutex locks and condition variables to implement dependencies between tasks, and provide specific code examples.

First, we need to define a task structure, which contains task-related information and dependencies. The specific code is as follows:

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
}

Then, we can define a task execution function, which will wait for the dependent tasks to complete before executing. The specific code is as follows:

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()
}

In addition, we You also need to define a method that waits for the task to complete. This method will block when the task is not completed until it returns after the task is completed. The specific code is as follows:

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

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

Finally, we can create multiple tasks and set their dependencies for concurrent execution. The specific code is as follows:

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.")
}

In the above code, we create three tasks, set the dependencies between them, then start the tasks concurrently, and finally block and wait for the last task to complete. When the task is completed, we print "All tasks completed.".

By using mutex locks and condition variables, we can solve concurrent task dependency problems in Go language. This approach ensures that tasks are executed in the correct order, avoiding data races and uncertain results. At the same time, using mutex locks and condition variables can improve program flexibility and concurrency performance.

Of course, in addition to mutexes and condition variables, the Go language also provides some other concurrency primitives, such as channels (Channel) and WaitGroup, etc. You can choose the appropriate solution according to actual needs.

The above is the detailed content of How to solve the problem of concurrent task dependency in Go language?. For more information, please follow other related articles on the PHP Chinese website!