How to safely interact with channels in goroutines in Golang

Question

I am new to go and I am trying to understand the way channels in goroutines work. To my understanding, the keyword range could be used to iterate over a the values of the channel up until the channel is closed or the buffer runs out; hence, a for range c will repeatedly loops until the buffer runs out.

I have the following simple function that adds value to a channel:

func main() {

    c := make(chan int)
    go printchannel(c)
    for i:=0; i<10 ; i++ {
        c <- i
    }

}

I have two implementations of printchannel and I am not sure why the behaviour is different.

Implementation 1:

func printchannel(c chan int) {
    for range c {
        fmt.Println(<-c)
    }
}

output: 1 3 5 7

Implementation 2:

func printchannel(c chan int) {
    for i:=range c {
        fmt.Println(i)
    }
}

output: 0 1 2 3 4 5 6 7 8

And I was expecting neither of those outputs!

Wanted output: 0 1 2 3 4 5 6 7 8 9

Shouldnt the main function and the printchannel function run on two threads in parallel, one adding values to the channel and the other reading the values up until the channel is closed? I might be missing some fundamental go/thread concept here and pointers to that would be helpful.

Feedback on this (and my understanding to channels manipulation in goroutines) is greatly appreciated!

Answer 1

The reason your first implementation only returns every other number is because you are, in effect "taking" from c twice each time the loop runs: first with range, then again with <-. It just happens that you're not actually binding or using the first value taken off the channel, so all you end up printing is every other one.

An alternative approach to your first implementation would be to not use range at all, e.g.:

func printchannel(c chan int) {
    for {
        fmt.Println(<-c)
    }
}

I could not replicate the behavior of your second implementation, on my machine, but the reason for that is that both of your implementations are racy - they will terminate whenever main ends, regardless of what data may be pending in a channel or however many goroutines may be active.

As a closing note, I'd warn you not to think about goroutines as explicitly being "threads", though they have a similar mental model and interface. In a simple program like this it's not at all unlikely that Go might just do it all using a single OS thread.

Answer 2

In implementation 1, range reads into channel once, then again in Println. Hence you're skipping over 2, 4, 6, 8.

In both implementations, once the final i (9) has been sent to goroutine, the program exits. Thus goroutine does not have the time to print out 9. To solve it, use a WaitGroup as has been mentioned in the other answer, or a done channel to avoid semaphore/mutex.

func main() {

    c := make(chan int)
    done := make(chan bool)
    go printchannel(c, done)
    for i:=0; i<10 ; i++ {
        c <- i
    }
    close(c)
    <- done
}

func printchannel(c chan int, done chan bool) {
    for i := range c {
        fmt.Println(i)
    }
    done <- true
}

Answer 3

Implementation 1. You're reading from the channel twice - range c and <-c are both reading from the channel.

Implementation 2. That's the correct approach. The reason you might not see 9 printed is that two goroutines might run in parallel threads. In that case it might go like this:

1. main goroutine sends 9 to the channel and blocks until it's read
2. second goroutine receives 9 from the channel
3. main goroutine unblocks and exits. That terminates whole program which doesn't give second goroutine a chance to print 9

In case like that you have to synchronize your goroutines. For example, like so

func printchannel(c chan int, wg *sync.WaitGroup) {
    for i:=range c {
        fmt.Println(i)
    }

    wg.Done() //notify that we're done here
}

func main() {
    c := make(chan int)
    wg := sync.WaitGroup{}

    wg.Add(1) //increase by one to wait for one goroutine to finish
              //very important to do it here and not in the goroutine
              //otherwise you get race condition

    go printchannel(c, &wg) //very important to pass wg by reference
                            //sync.WaitGroup is a structure, passing it
                            //by value would produce incorrect results

    for i:=0; i<10 ; i++ {
        c <- i
    }

    close(c)  //close the channel to terminate the range loop
    wg.Wait() //wait for the goroutine to finish
}

As to goroutines vs threads. You shouldn't confuse them and probably should understand the difference between them. Goroutines are green threads. There're countless blog posts, lectures and stackoverflow answers on that topic.

Answer 4

Your first loop does not work as you have 2 blocking channel receivers and they do not execute at the same time.

When you call the goroutine the loop starts, and it waits for the first value to be sent to the channel. Effectively think of it as <-c .

When the for loop in the main function runs it sends 0 on the Chan. At this point the range c recieves the value and stops blocking the execution of the loop.

Then it is blocked by the reciever at fmt.println(<-c) . When 1 is sent on the second iteration of the loop in main the recieved at fmt.println(<-c) reads from the channel, allowing fmt.println to execute thus finishing the loop and waiting for a value at the for range c .

Your second implementation of the looping mechanism is the correct one. The reason it exits before printing to 9 is that after the for loop in main finishes the program goes ahead and completes execution of main.

In Go func main is launched as a goroutine itself while executing. Thus when the for loop in main completes it goes ahead and exits, and as the print is within a parallel goroutine that is closed, it is never executed. There is no time for it to print as there is nothing to block main from completing and exiting the program.

One way to solve this is to use wait groups http://www.golangprograms.com/go-language/concurrency.html

In order to get the expected result you need to have a blocking process running in main that provides enough time or waits for confirmation of the execution of the goroutine before allowing the program to continue.