将顺序测试分散到4个go例程中，如果一个失败则终止所有例程

Question

Suppose I have a simple loop which does sequential tests like this.

 for f := 1; f <= 1000; f++ {
            if doTest(f) {
              break
            }
  }

I loop through range of numbers and do a test for each number. If test fails for one number, I break and exit the main thread. Simple enough.

Now, how do correctly feed the test numbers in say four or several go routines. Basically, I want to test the numbers from 1 to 1000 in batches of 4 (or whatever number of go routines is). Do I create 4 routines reading from one channel and feed the numbers sequentially into this channel? Or do I make 4 routines with an individual channel?

And another question. How do I stop all 4 routines if one of them fails the test? I've been reading some texts on channels but I cannot put the pieces together.

Answer 1

You can create a producer/consumer system: https://play.golang.org/p/rks0gB3aDb

func main() {
    ch := make(chan int)
    clients := 4
    // make it buffered, so all clients can fail without hanging
    notifyCh := make(chan struct{}, clients)
    go produce(100, ch, notifyCh)

    var wg sync.WaitGroup
    wg.Add(clients)
    for i := 0; i < clients; i++ {
        go func() {
            consumer(ch, notifyCh)
            wg.Done()
        }()
    }
    wg.Wait()

}

func consumer(in chan int, notifyCh chan struct{}) {
    fmt.Printf("Start consumer
")
    for i := range in {
        <-time.After(100 * time.Millisecond)
        if i == 42 {
            fmt.Printf("%d fails
", i)
            notifyCh <- struct{}{}
            return
        } else {
            fmt.Printf("%d
", i)
        }

    }
    fmt.Printf("Consumer stopped working
")
}

func produce(N int, out chan int, notifyCh chan struct{}) {
    for i := 0; i < N; i++ {
        select {
        case out <- i:
        case <-notifyCh:
            close(out)
            return
        }
    }
    close(out)
}

The producer pushes numbers from 0 to 99 to the channel, the consumer consumes until the channel is closed. In main we create 4 clients and add them to a waitgroup to reliably check if every goroutine returned. Every consumer can signal on the notifyCh, the producer stops working and no further numbers are generated, therefor all consumers return after their current number.

There's also an option to create 4 go routines, wait for all of them to return, start the next 4 go routines. But this adds quite an overhead on waiting.

Since you mentioned prime numbers, here's a really cool prime seive: https://golang.org/doc/play/sieve.go