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

package main
import (
    "fmt"
    "sync"
    "time"
)
func main() {
    varwg sync.WaitGroup
    fori := 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结束时传送一个标示给信道。
}

 

方法二：美化版

funcCount(ch chanint) {
    ch <- 1
    fmt.Println("Counting")
}
funcmain() {
    chs := make([] chanint, 10)
    fori:=0; i<10; i++ {
        chs[i] = make(chanint)
        goCount(chs[i])
    }
    for_, ch := range(chs) {
        <-ch
    }
}
这个写得还不错~