golang中如何阻塞等待所有goroutines都完成

方案一：
也是推荐方案，也是官方推荐方案，涉及到一个写并发经常关注的模块sync模块，利用里面的sync.WaitGroup去做
代码如下：

package main

import (

    "fmt"

    "sync"

    "time"

)

func main() {

    var wg sync.WaitGroup

    for i := 0; i < 5; i = i + 1 {

        wg.Add(1)

        go func(n int) {

            // defer wg.Done()

            defer wg.Add(-1)

            EchoNumber(n)

        }(i)

    }

    wg.Wait()

}

func EchoNumber(i int) {

    time.Sleep(3e9)

    fmt.Println(i)

}

方案二：
思路也不绕路，利用的channel的阻塞机制，直接上代码了。
package main
import(
        "fmt"
        "time"
        "runtime"
)
var num=14 //定义一工并发多少数量
var cnum chan int
func main(){
   maxProcs := runtime.NumCPU()// 获取cpu个数
    runtime.GOMAXPROCS(maxProcs)//限制同时运行的goroutines数量
    cnum=make(chan int,num) //make一个chan,缓存为num
    for i:=0;i<num;i++{
            go Printer(i)
    }
// 下面这个for循环的意义就是利用信道的阻塞，一直从信道里取数据，直到取得跟并发数一样的个数的数据，则视为所有goroutines完成。
    for i:=0;i<num;i++{
            <-cnum
    }
    fmt.Println("WE DONE!!!")
}
func Printer(a int)(){
        time.Sleep(2000 * time.Millisecond)
        fmt.Printf("i am %d\n",a)
        cnum <- 1 //goroutine结束时传送一个标示给信道。
}

 

方法二：美化版

func Count(ch chan int) {

    ch <- 1

    fmt.Println("Counting")

}

func main() {

    chs := make([] chan int, 10)

    for i:=0; i<10; i++ {

        chs[i] = make(chan int)

        go Count(chs[i])

    }

    for _, ch := range(chs) {

        <-ch

    }

}

这个写得还不错~

https://www.cnblogs.com/liang1101/p/7285955.html