Would you tell me how work golang channel buffer? - go

Question

Why dose not work buffer to right on the golang?
If channel become full, it is wait. This is wrong?
I don't understand how it work.
Would you tell me how work golang channel buffer?
import (
"fmt"
"runtime"
);
func main() {
runtime.GOMAXPROCS(1);
done := make(chan bool, 2);
count := 4;
go func() {
for i := 0; i < count; i++ {
done <- true
fmt.Println("AAAAAAAA", i);
}
}()
for j := 0; j < count; j++ {
<-done
fmt.Println("BBBBBBBBBB", j);
}
}
---------------------------------------------------------------------------------
AAAAAAAAAAAAAAA 0
AAAAAAAAAAAAAAA 1
AAAAAAAAAAAAAAA 2
BBBBBBBBBB 0
BBBBBBBBBB 1
BBBBBBBBBB 2
BBBBBBBBBB 3
This is my expect
AAAAAAAAAAAAAAA 0
AAAAAAAAAAAAAAA 1
BBBBBBBBBB 0
BBBBBBBBBB 1
AAAAAAAAAAAAAAA 2
AAAAAAAAAAAAAAA 3
BBBBBBBBBB 2
BBBBBBBBBB 3

Answer 1

The channel buffer only fills up if Go is unable to process one item before the next arrives. In your case, there's no backlog of items as each is processed quickly and efficiently.

Answer 2

I wanted to understand the anatomy of channels and I've made almost the same code that You've made. I've made some small changes in your code
func main() {
runtime.GOMAXPROCS(1)
done := make(chan int, 2)
count := 4
go func() {
defer close(done)
for i := 0; i < count; i++ {
done <- i
fmt.Println("AAAAAAAA", i)
}
}()
for j := 0; j < count; j++ {
i, ok := <-done
if !ok {
break
}
fmt.Println("BBBBBBBBBB", i)
}
time.Sleep(1 * time.Millisecond)
}
Now, the output will be this
AAAAAAAA 0
AAAAAAAA 1
AAAAAAAA 2
BBBBBBBBBB 0
BBBBBBBBBB 1
BBBBBBBBBB 2
BBBBBBBBBB 3
AAAAAAAA 3
I have found an interesting information about this in the book of Concurrency in Go - by Cox-Buday, Katherine
It also bears mentioning that if a buffered channel is empty and has a
receiver, the buffer will be bypassed and the value will be passed
directly from the sender to the receiver.
According this information my understanding is, when we have a buffered channel with capacity 2:
-> main goroutine is blocked, because the channel is empty
AAAAAAAA 0 -> because, there is an active receiver this value bypassed the channel
AAAAAAAA 1 -> this value is the first value in the channel
AAAAAAAA 2 -> this value is the second value in the channel and channel is full now, so this goroutine is blocked
BBBBBBBBBB 0 -> the main goroutine can unblock now and read the "bypassed" value
-> i think the anonymous goroutine can pass the third value to channel somewhere i here
BBBBBBBBBB 1 -> the main goroutine reads the first value from the channel
BBBBBBBBBB 2 -> the main goroutine reads the second value from the channel
BBBBBBBBBB 3 -> the main goroutine reads the third value
-> the main goroutine blocked by sleep
AAAAAAAA 3 -> the anonymous goroutine can run the print statement
I'm not 100% sure this happening, but It is my observation. Unbuffered channel is also buffered channel but with 0(or 1) capacity. It is also interesting, if you try your code with 0 (unbuffered) capacity. The result will be something like this:
AAAAAAAA 0
BBBBBBBBBB 0
BBBBBBBBBB 1
AAAAAAAA 1
AAAAAAAA 2
BBBBBBBBBB 2
BBBBBBBBBB 3
AAAAAAAA 3
Finally, here is my code. I used buffer for storing the results and write it out to stdout only at the end of the main function.
func main() {
runtime.GOMAXPROCS(1)
var stdoutBuff bytes.Buffer
defer stdoutBuff.WriteTo(os.Stdout)
intStream := make(chan int, 0)
go func() {
defer close(intStream)
defer fmt.Fprintln(&stdoutBuff, "Producer done.")
for i := 0; i < 5; i++ {
fmt.Fprintf(&stdoutBuff, "Before Sending: %d\n", i)
intStream <- i
fmt.Fprintf(&stdoutBuff, "After Sending: %d\n", i)
}
}()
// for integer := range intStream {
// fmt.Fprintf(&stdoutBuff, "Received: %v\n", integer)
// }
for {
fmt.Fprintf(&stdoutBuff, "Before received.\n")
v, ok := <-intStream
if !ok {
break
}
fmt.Fprintf(&stdoutBuff, "Received: %v\n", v)
}
}
I hope it helps a little bit.