Search code examples
concurrencygotimeoutthread-sleepbusy-waiting

Go times out on sleep but not on busy-wait


In Go, I can use time.After to time out a sleeping function, but I can't do the same to a function that is busy-waiting (or working). The following code returns timed out after one second, and then hangs.

package main

import (
        "fmt"
        "time"
)

func main() {
        sleepChan := make(chan int)
        go sleep(sleepChan)
        select {
        case sleepResult := <-sleepChan:
                fmt.Println(sleepResult)
        case <-time.After(time.Second):
                fmt.Println("timed out")
        }

        busyChan := make(chan int)
        go busyWait(busyChan)
        select {
        case busyResult := <-busyChan:
                fmt.Println(busyResult)
        case <-time.After(time.Second):
                fmt.Println("timed out")
        }
}

func sleep(c chan<- int) {
        time.Sleep(10 * time.Second)
        c <- 0
}

func busyWait(c chan<- int) {
        for {
        }
        c <- 0
}

Why doesn't the timeout fire in the second case, and what alternative do I need to use to interrupt working goroutines?


Solution

  • The for {} statement is an infinite loop which monopolizes a single processor. Set runtime.GOMAXPROCS to 2 or more to allow the timer to run.

    For example,

    package main
    
    import (
        "fmt"
        "runtime"
        "time"
    )
    
    func main() {
        fmt.Println(runtime.GOMAXPROCS(0))
        runtime.GOMAXPROCS(runtime.NumCPU())
        fmt.Println(runtime.GOMAXPROCS(0))
        sleepChan := make(chan int)
        go sleep(sleepChan)
        select {
        case sleepResult := <-sleepChan:
            fmt.Println(sleepResult)
        case <-time.After(time.Second):
            fmt.Println("timed out")
        }
    
        busyChan := make(chan int)
        go busyWait(busyChan)
        select {
        case busyResult := <-busyChan:
            fmt.Println(busyResult)
        case <-time.After(time.Second):
            fmt.Println("timed out")
        }
    }
    
    func sleep(c chan<- int) {
        time.Sleep(10 * time.Second)
        c <- 0
    }
    
    func busyWait(c chan<- int) {
        for {
        }
        c <- 0
    }
    

    Output (4 CPU processor):

    1
    4
    timed out
    timed out