golang递归函数调用自己作为goroutine不能按预期方式工作[重复]

This recursive function works as expected (returns 5 lines with numbers 5 to 1):

package main
import (
    "fmt"
)
func recur(iter int) {
    if iter <= 0 {
        return
    }
    fmt.Println(iter)
    recur(iter-1)
}
func main() {
    recur(5)
}

this one does not (returns only 1 line with number 5):

    package main
import (
    "fmt"
)
func recur(iter int) {
    if iter <= 0 {
        return
    }
    fmt.Println(iter)
    go recur(iter-1)
}
func main() {
    recur(5)
}

The difference is that in the second implementation, function calls itself as a goroutine. (line go recur(iter-1) )

So can someone explain this behaviour?

</div>

If you make everything asynchronous, there is nothing in main to wait on. You have to explicitly wait on the go routines so your program does not exit before the recursive process finishes.

Use sync.WaitGroup or something similar for synchronization. Example (On Play):

func recur(iter int, g *sync.WaitGroup) {
    defer g.Done()
    if iter <= 0 {
        return
    }
    fmt.Println(iter)
    go recur(iter-1, g)
}

func main() {
    g := &sync.WaitGroup{}
    runs := 5
    g.Add(runs)
    recur(runs, g)
    g.Wait()
}

Your programming is exiting before all the goroutines finish. The simplest way to see this work is as follows.

package main

import (
    "fmt"
    "time"
)

func recur(iter int) {
    if iter <= 0 {
        return
    }
    fmt.Println(iter)
    go recur(iter - 1)
}
func main() {
    recur(5)
    time.Sleep(time.Second)
}

playground link

Rather than sleeping, however, you may want to pass a sync.WaitGroup through to your function.