Как заставить несколько подпрограмм идти ждать некоторого вывода из другой программы

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, рутиной_3to рутинная_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

Вы можете сделать это, например, .. -создать задачу с последующим результатом -результат использовать в качестве другой задачи .. -использовать waitgroup (пакет синхронизации prperty) в основном для функции ожидания .. -использовать функцию лямда и интервал времени (time.sleep)(время.сек / мин). -Вот зависимости от задачи использовать Mutex (блокировка / разблокировка)

Answer 3

Вы можете использовать закрытие канала для трансляции готовности результата и использовать общую переменную для сохранения результата:

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

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

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

Вы можете иметь много процедур, ожидающих закрытия канала. Когда канал закроется, все функции будут включены.