go - 在嵌入式结构之间传递数据的最惯用的方法是什么？

Question

我有两个结构

//Pseudo code
type task struct {}
type tasks struct []{
     t task 
}

我要运行一个任务，然后将其传递给任务:例如，在task1和task2完成之后，通知tasks，然后运行task3。因此，这个task.finished()必须通知tasks.和tasks必须确保task1和task2均已完成，然后才能触发task3。

 //Pseudo code    
 task1.start() and task2.start() at the same time

 if  task1.finished() && task2.finished():
     task3.run()

在嵌入式结构之间传递数据的最惯用的方法是什么？

我知道应该在tasks中进行这种逻辑处理，但是task1和task2如何告诉tasks他们完成了？

我是否应该引入一个新结构来存储交换所需的信息，称为“taskManager”？

Answer 1

type tasks []*task

type task struct {
    Data       int
    onComplete chan struct{}
}

var wg sync.WaitGroup

// each task will in one goroutine
// pointer receiver
func (t *task) Run() {
    defer wg.Done()

    sleepTime := time.Second * time.Duration(t.Data)

    fmt.Println("Task:", t.Data, "sleeping for", sleepTime)
    time.Sleep(sleepTime)

    fmt.Println("Task:", t.Data, "done")

    // Once work is done, Inform, if we have to
    if t.onComplete != nil {
        t.onComplete <- struct{}{}
    }
}

// Run given tasks
func Run(ts tasks) {
    wg.Add(len(ts))

    for _, t := range ts {
        // run each task in seperate goroutines
        go t.Run()
    }
}

func (ts tasks) OnComplete(pending tasks) {
    tempChan := make(chan struct{})

    // all tasks should inform to `tempChan`,
    // once done
    for _, t := range ts {
        t.onComplete = tempChan
    }

    tasksNum := len(ts)

    wg.Add(1)
    go func() {
        // once we receive enough signals
        // i.e., once all `ts` tasks are done run pending tasks
        for range tempChan {
            tasksNum--
            if tasksNum == 0 {
                Run(pending)
                close(tempChan)
            }
        }
        wg.Done()
    }()
}

func main() {

    // define tasks
    mainTasks := tasks{
        {Data: 1},
        {Data: 2},
    }

    // tasks which need to run once certain tasks were done
    pendingTasks := tasks{
        {Data: 3},
    }

    // Inform to run pending tasks once mainTasks are done
    mainTasks.OnComplete(pendingTasks)

    // start runing your main tasks
    Run(mainTasks)

    wg.Wait()
}

Go PlayGround

实际上，您可以继续链接工作，

然后运行pendingTasks.OnComplete(someMoreTasks)，一旦完成将运行mainTasks，一旦完成将运行PendingTasks。

其他种类的复杂关系也是可能的。