理解代码：通过交流共享资源

Question

I've been trying to understand the code in https://golang.org/doc/codewalk/sharemem/ Though I get most of the part about passing resources via channel, I'm unable to understand the infinite loop the program runs in. How does the program execute Poller function infinitely when the "in" channel in poller function(that receives from main function) run only 3 poller go routines ?

I get the idea of StateMonitor having anonymous go function with infinite loop. But it can't update LogState without receiving from Poller function. I'm assuming the program performs Get request to the urls infinitely.

To confirm that I'm not wrong about what I've understood, I tested the program by turning the wifi on and off to see if the log changes. To my surprise, it does, for few iterations but after that it stops responding to my change and keeps on showing the same log. So, does that mean program is buggy? Or is it that I haven't understood some fundamental concepts?

Answer 1

How does the program execute Poller function infinitely when the "in" channel in poller function(that receives from main function) run only 3 poller go routines ?

So, first the program creates two Pollers:

for i := 0; i < numPollers; i++ {
    go Poller(pending, complete, status)
}

then it sends three resources to pending:

for _, url := range urls {
    pending <- &Resource{url: url}
}

Every Poller reads from pending and polls the resource:

for r := range in {
    s := r.Poll()
    status <- State{r.url, s}
    out <- r
}

This code seems to be executed infinitely, but it is blocking read from a queue, generally. So this loops wait for the next value to appear.

Let's virtually step over it:

1. There is two Pollers reading resources.
2. Program sends first resource to the queue.
3. One of the pollers gets the resource and start to pool. Another one waits.
4. At some moment the program sends new resource to the queue.
5. As the first poller is busy, the second one gets unblocked and start polling.
6. Program sends third resource and blocks as two pollers are busy.
7. When one of the pollers completes, it takes the last resource and continues.
8. At the meantime, the main program reads values from the complete queue.

for r := range in { s := r.Poll() status <- State{r.url, s} out <- r } How does this code run infinitely? If it loops over "in" channel, and "in" gets its resources from pending queue, it should terminate after few iterations. I think this is exactly the part that I don't understand.

To be precise, in does not gets the resources from pending queue. in is pending queue. The queue (or channel, which I use interchangeably) can be closed by calling close but until it is not closed explicitly it is considered alive. Any reading from it blocks the current goroutine until the next value will be given. Then gorotine resumes.

I suppose that you keep thinking about channels like they are array with fixed number of elements. They are not. Consider they like array with infinite number of elements but with blocking read that may throw exception (that the rough approximation of closing the queue if you are not familiar with the concept).