如何优雅的控制goroutine的数量

1,为什么要控制goroutine的数量？

goroutine固然好，但是数量太多了，往往会带来很多麻烦，比如耗尽系统资源导致程序崩溃，或者CPU使用率过高导致系统忙不过来。比如：

 for i:=; i < ; i++ {
     go work()
 }

2,用什么方法控制goroutine的数量？

要在每一次执行go之前判断goroutine的数量，如果数量超了，就要阻塞go的执行。第一时间想到的就是使用通道。每次执行的go之前向通道写入值，直到通道满的时候就阻塞了，如下：

 var ch chan int

 func work() {
     //do something
     <-ch
 }

 func main() {
     ch = make(chan int, )
     for i:=; i < ; i++ {
        ch <-
        go work()
     }
 }

这样每次同时运行的goroutine就被限制为10个了。但是新的问题出现了，因为并不是所有的goroutine都执行完了，在main函数退出之后，还有一些goroutine没有执行完就被强制结束了。这个时候我们就需要用到sync.WaitGroup。使用WaitGroup等待所有的goroutine退出。如下：

 var wg *sync.WaitGroup

 func work() {
     defer wg.Done()
     //do something
 }

 func main() {
     wg = &sync.WaitGroup{}
     for i:=; i < ; i++ {
        wg.Add()
        go work()
     }
     wg.Wait()//等待所有goroutine退出
 }

3,优雅的使用并控制goroutine的数量

综上所述，我们封装一下，代码如下：

 package gpool

 import (
     "sync"
 )

 type pool struct {
     queue chan int
     wg    *sync.WaitGroup
 }

 func New(size int) *pool {
     if size <=  {
         size =
     }
     return &pool{
         queue: make(chan int, size),
         wg:    &sync.WaitGroup{},
     }
 }

 func (p *pool) Add(delta int) {
     for i := ; i < delta; i++ {
         p.queue <-
     }
     for i := ; i > delta; i-- {
         <-p.queue
     }
     p.wg.Add(delta)
 }

 func (p *pool) Done() {
     <-p.queue
     p.wg.Done()
 }

 func (p *pool) Wait() {
     p.wg.Wait()
 }

来段测试代码：

 package gpool_test

 import (
     "runtime"
     "testing"
     "time"
     "gpool"
 )

 func Test_Example(t *testing.T) {
     pool := gpool.New()
     println(runtime.NumGoroutine())
     for i := ; i < ; i++ {
         pool.Add()
         go func() {
             time.Sleep(time.Second)
             println(runtime.NumGoroutine())
             pool.Done()
         }()
     }
     pool.Wait()
     println(runtime.NumGoroutine())
 }

good job，Over～