Concurrency – printing to stdout results in blocked goroutine runs?

As a stupid basic threading exercise, I've been trying to implement sleeping barber problem in golang It should be easy to have channels, but I met heisenbug That is, when I try to diagnose it, the problem disappears!

Consider the following The main () function pushes an integer (or "customer") to the store channel Barber reads the store channel to cut off the "customer's" hair If I will FMT The print statement inserts the customer () function and the program will run as expected Otherwise, the barber will never cut anyone's hair

package main

import "fmt"

func customer(id int,shop chan<- int) {
    // Enter shop if seats available,otherwise leave
    // fmt.Println("Uncomment this line and the program works")
    if len(shop) < cap(shop) {
        shop <- id
    }
}

func barber(shop <-chan int) {
    // Cut hair of anyone who enters the shop
    for {
        fmt.Println("Barber cuts hair of customer",<-shop)
    }
}

func main() {
    shop := make(chan int,5) // five seats available
    go barber(shop)
    for i := 0; ; i++ {
        customer(i,shop)
    }
}

Do you know what's happening?

Solution

The problem is the implementation of go scheduler The current goroutine can generate other goroutines only during system call or channel blocking operation fmt. Println makes a system call, providing goroutine with an opportunity to yield Otherwise there would be No

In practice, this is usually not important, but for small problems like this, it sometimes pops up

In addition, the more common and less vivid way of non blocking transmission on the channel is:

func customer(id int,otherwise leave
    select {
    case shop <- id:
    default:
    }
}

The way you do this, the customer may eventually wait outside the barber shop, because when you actually send the email, len (store) may have changed