等待同步.Waitgroup推迟

I have the following code that goes into deadlock when sending on channel from a goroutine below:

package main

import (
    "fmt"
    "sync"
)

func main() {
    for a := range getCh(10) {
        fmt.Println("Got:", a)
    }
}

func getCh(n int) <-chan int {
    var wg sync.WaitGroup
    ch := make(chan int)
    defer func() {
        fmt.Println("closing")
        wg.Wait()
        close(ch)
    }()
    wg.Add(1)
    go func() {
        defer wg.Done()
        for i := 0; i < n; i++ {
            ch <- i
        }
    }()
    wg.Add(1)
    go func() {
        defer wg.Done()
        for i := n; i < 0; i-- {
            ch <- i
        }
    }()

    return ch
}

I know that it is legal to use wg.Wait() in defer. But I haven't been able to find a use in a function with channel as a return value.

I think the mistake you're making is that you think that the deferred function will run asynchronously too. But that is not the case, so the getCh() will block in its deferred part, waiting for the WaitGroup. But as there is no one reading from the channel, the goroutines which write into it can't return and thus the WaitGroup causes deadlock. Try something like this:

func getCh(n int) <-chan int {
    ch := make(chan int)
    go func() {
        var wg sync.WaitGroup
        wg.Add(1)
        go func(n int) {
            defer wg.Done()
            for i := 0; i < n; i++ {
                ch <- i
            }
        }(n)
        wg.Add(1)
        go func(n int) {
            defer wg.Done()
            for i := n; i > 0; i-- {
                ch <- i
            }
        }(n)
        wg.Wait()
        fmt.Println("closing")
        close(ch)
    }()

    return ch
}

It looks like your channels are blocking since you are not using any buffered channels. check out this quick example https://play.golang.org/p/zMnfA33qZk

ch := make(chan int, n)

Remember that channels block when they are filled. I am not sure what your goal is with your code, but it looks like you were aiming for using a buffered channel. This is a good piece from effective go https://golang.org/doc/effective_go.html#channels

Receivers always block until there is data to receive. If the channel is unbuffered, the sender blocks until the receiver has received the value. If the channel has a buffer, the sender blocks only until the value has been copied to the buffer; if the buffer is full, this means waiting until some receiver has retrieved a value.