Why is this Go code deadlocking?

package main

import "fmt"
import "runtime"
import "time"


func check(id int) {
	fmt.Println("Checked", id)
	<-time.After(time.Duration(id)*time.Millisecond)
	fmt.Println("Woke up", id)
}

func main() {
	defer runtime.Goexit()
	
	for i := 0; i <= 10; i++ {
		fmt.Println("Called with", i)
		go check(i)
	}
	
	fmt.Println("Done for")
}

I'm very new to Go, so any pointers would be great. How would I go about debugging such a thing?

You can run the snippet http://play.golang.org/p/SCr8TZXQUE

update: this works without the line <-time.After(time.Duration(id)*time.Millisecond) on playground, I want to know why? (As mentioned by @dystroy this maybe because of the way playground handles time)

When I try locally, this is the output:

Called with  0
Called with  1
Checked 0
Called with  2
Checked 1
Called with  3
Checked 2
Called with  4
Woke up 0
Checked 3
Called with  5
Checked 4
Called with  6
Checked 5
Called with  7
Checked 6
Called with  8
Checked 7
Called with  9
Checked 8
Called with  10
Checked 9
Woke up 1
Done for
Checked 10
Woke up 2
Woke up 3
Woke up 4
Woke up 5
Woke up 6
Woke up 7
Woke up 8
Woke up 9
Woke up 10
throw: all goroutines are asleep - deadlock!

goroutine 2 [syscall]:
created by runtime.main
	/tmp/bindist046461602/go/src/pkg/runtime/proc.c:221

goroutine 5 [timer goroutine (idle)]:
created by addtimer
	/tmp/bindist046461602/go/src/pkg/runtime/ztime_amd64.c:69
exit status 2

All the goroutines complete but throws a deadlock anyway. I should note that it doesn't matter if the timer is used, deadlocks either way.

From the documentation of Goexit :

> Goexit terminates the goroutine that calls it. No other goroutine is affected. Goexit runs all deferred calls before terminating the goroutine.

You're exiting the main routine. Don't. As you do it, there isn't any routine running after the last one you launched with go check(i) has finished, hence the "deadlock". Simply remove this line :

defer runtime.Goexit()

If what you want is to wait in main for a group of goroutines to finish, you may use a sync.WaitGroup :

package main

import (
    "fmt"
    "sync"
    "time"
)

func check(id int, wg *sync.WaitGroup) {
    fmt.Println("Checked", id)
    <-time.After(time.Duration(id)*time.Millisecond)
    fmt.Println("Woke up", id)
    wg.Done()
}

func main() {
	var wg sync.WaitGroup
    for i := 0; i <= 10; i++ {
        wg.Add(1)
        fmt.Println("Called with", i)
        go check(i, &wg)
    }
	wg.Wait()
    fmt.Println("Done for")
}

EDIT :

if you're testing it on golang's playground, any time.After will deadlock because time is frozen in playground and Goexit maybe exit a routine that doesn't even exist in a standard program.

all your goroutines are waiting for someone to consume the value they are sending in <-time.After.
you can just delete the <- or make main consume the value of all goroutines you launched.

Edit

this worked for me

package main

import "fmt"
//import "runtime"
import "time"


func check(id int) {
    fmt.Println("Checked", id)
    <-time.After(time.Duration(id)*time.Millisecond)
    fmt.Println("Woke up", id)
}

func main() {
    //defer runtime.Goexit()

    for i := 0; i <= 10; i++ {
        fmt.Println("Called with", i)
        go check(i)
    }

    fmt.Println("Done for")
}

witch is the same solution someone proposed before so I'll propose a solution without a waitgroup

package main

import "fmt"
import "time"


func check(id int, c chan bool) {
    fmt.Println("Checked", id)
    time.After(time.Duration(id)*time.Millisecond)
    fmt.Println("Woke up", id)
    c <- true
}

func main() {
    c := make(chan bool)

    for i := 0; i <= 10; i++ {
        fmt.Println("Called with", i)
        go check(i, c)
    }
    var n uint
    for n<10 {
    	<- c
    	n++
    }
    fmt.Println("Done for")
}