Concurrency 这是怎么泄露的？

我试图理解这张幻灯片上概述的问题：

在URL死亡的情况下复制代码：

func sendMsg(msg, addr string) error {
    conn, err := net.Dial("tcp", addr)
    if err != nil {
        return err
    }
    defer conn.Close()
    _, err = fmt.Fprint(conn, msg)
    return err
}

func broadcastMsg(msg string, addrs []string) error {
    errc := make(chan error)
    for _, addr := range addrs {
        go func(addr string) {
            errc <- sendMsg(msg, addr)
            fmt.Println("done")
        }(addr)
    }

    for _ = range addrs {
        if err := <-errc; err != nil {
            return err
        }
    }
    return nil
}

func main() {
    addr := []string{"localhost:8080", "http://google.com"}
    err := broadcastMsg("hi", addr)

    time.Sleep(time.Second)

    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("everything went fine")
}

func sendMsg（msg，addr string）错误{
连接，错误：=网络拨号（“tcp”，地址）
如果错误！=零{
返回错误
}
延迟连接关闭（）
_，err=fmt.Fprint（连接，消息）
返回错误
}
func broadcastMsg（消息字符串，地址[]字符串）错误{
errc:=制造（chan错误）
对于u，addr:=范围addr{
go func（地址字符串）{
errc


函数文字表示匿名函数

FunctionLit = "func" Function .

func(a, b int, z float64) bool { return a*b < int(z) }

自
len（addrs）==2
以来启动了两个goroutine。由于在通道
errc
上第一次接收时
err！=nil
过早退出，只有一个goroutine完成。第二个goroutine在发送时被阻止（写入）对于无缓冲通道
errc
，它永远不会完成。因此，仍然存在对
errc
的引用，因此它永远不会被垃圾收集。当程序退出时，第二个goroutine最终被放弃

f := func(x, y int) int { return x + y }
func(ch chan int) { ch <- ACK }(replyChan)

SendStmt = Channel "<-" Expression .
Channel  = Expression .

func broadcastMsg(msg string, addrs []string) error {
    errc := make(chan error)
    for _, addr := range addrs {
        go func(addr string) {
            errc <- sendMsg(msg, addr)
            fmt.Println("done")
        }(addr)
    }

    for _ = range addrs {
        if err := <-errc; err != nil {
            return err
        }
    }
    return nil
}