Question

Main {
go routine_1(carryout a time consuming task and return output)
go routine_2(wait for output from routine_1, collect output and do task_2)
go routine_3(wait for output from routine_1, collect output and do task_3)
wait for all routines to complete
}

我使用过通道，但是一旦例程_2读取了数据，例程_3就无法获取数据。

我不希望主线程进行同步，即知道例程_2，例程_3与例程_1之间的依赖关系

最终关闭该频道将为其他例程提供所需的广播，以使其知道结果已准备就绪。

谢谢您的时间。（这是我在stackoverflow中的第一个问题，非常高兴看到如此高的质量和快速的响应）

更新我选择的答案。再次感谢。

package main

import (
    "fmt"
    "sync"
)

func computeResult() int {
    return 100
}

func main() {

    var wg sync.WaitGroup
    wg.Add(2)
    var output int

    ch := make(chan struct{})

    // Compute result
    go func() {
        defer wg.Done()
        output = computeResult()
        fmt.Println("closing channel to signal task done")
        close(ch)
        fmt.Println("channel closed")

    }()

    go func() {
        defer wg.Done()
        // Wait for ch close
        <-ch
        fmt.Println(output)
    }()

    wg.Wait()

    var wg2 sync.WaitGroup
    wg2.Add(1)

    go func() {
        defer wg2.Done()
        fmt.Println("wait on closed channel")
        // Wait for ch close
        <-ch
        fmt.Println(output)
    }()

    wg2.Wait()

}

Answer 1

您可以在第一个例程完成后调用其他两个例程：

var wg sync.WaitGroup
wg.Add(2)
go func() {
    output := task1()
    go func() {
        defer wg.done()
        task2(output)
    }
    go func() {
        defer wg.done()
        task3(output)
    }
}()
wg.Wait()

Answer 2

您可以使用频道的关闭来广播结果准备情况，并使用共享变量来存储结果：

func() {
   var output SomeType
   ch:=make(chan struct{})

   // Compute result
   go func() {
      output=computeResult()
      close(ch)
   }()

   go func() {
     // Wait for ch close
     <-ch
      useOutput()
    }()
}

您可以有许多goroutines等待通道关闭。通道关闭时，将启用所有goroutine。

Answer 3

您可以按照以下方式进行操作： -create任务，然后将result -result用作另一个任务。 -使用waitgroup（属性同步包）主要用于等待功能。 -使用lamda函数和时间间隔（time.sleep（time.sec / min）。 -在此基于任务依赖关系使用Mutex（锁定/解锁）

如何使多个go例程等待另一个goroutine的某些输出

3 个答案: