05.限制GO并发数

前言

开发过程中，如果不限制并发数，如下代码这种，可能直接造成服务器宕机，而且很多结果不会输出

[!TIP|style:flat]

很多结果不会输出，是因为主协程结束时，子协程也会终止掉。

func main() {
    userCount := math.MaxInt64
    for i := 0; i < userCount; i++ {
        go func(i int) {
            // 做一些各种各样的业务逻辑处理
            fmt.Printf("go func: %d\n", i)
            time.Sleep(time.Second)
        }(i)
    }
}

尝试chan

package main
import (
    "fmt"
    "math"
    "time"
)
func out(i int, semaphore chan bool){
    fmt.Printf("go func: %d\n", i)
    // 释放通道
    <- semaphore
    time.Sleep(time.Second)
}
func main() {
    semaphore := make(chan bool, 2)
    userCount := math.MaxInt8
    for i := 0; i < userCount; i++ {
        // 占用通道
        semaphore <- true
        go out(i, semaphore)
    }
}

确实可以2个协程并发，但是和上面结果一样，很多结果不会输出，是因为主协程结束时，子协程也会终止掉。

go func: 1
go func: 0
go func: 3
go func: 4
go func: 5
go func: 6
go func: 7
go func: 8

尝试sync

主要使用sync.WaitGroup{}

package main
import (
    "fmt"
    "math"
    "sync"
    "time"
)
var wg = sync.WaitGroup{}
func out(i int){
    fmt.Printf("go func: %d\n", i)
    time.Sleep(time.Second)
    wg.Done()
}
func main() {
    userCount := math.MaxInt8
    for i := 0; i < userCount; i++ {
        wg.Add(1)
        go out(i)
    }
    // 等待全部执行完
    wg.Wait()
}

所有结果都显示出来了，也就是说所有子协程都执行完了，但是没有控制并发数量

尝试chan+sync√

从上面2个可以看出，一个可以控制并发数量，另一个可以让所有子协程都执行完，所以结合一下，就能达到我们的目的了

package main
import (
    "fmt"
    "math"
    "sync"
    "time"
)
var wg = sync.WaitGroup{}
func out(i int, semaphone chan bool){
    fmt.Printf("go func: %d\n", i)
    time.Sleep(time.Second)
    // 释放通道
    <- semaphone
    defer wg.Done()
}
func main() {
    semaphone := make(chan bool, 2)
    userCount := math.MaxInt8
    for i := 0; i < userCount; i++ {
        wg.Add(1)
        // 占用通道
        semaphone <- true
        go out(i, semaphone)
    }
    // 等待全部执行完
    wg.Wait()
}

结合一下，确实能达到我们想到的效果了！！！就是结果有点乱，一般来说不影响了

go func: 1
go func: 0
go func: 3
go func: 2
go func: 4
go func: 5
go func: 6
go func: 7
go func: 8
go func: 9

信号量Semaphore

和Python中的信号量一样，感觉是结合了chan+sync，确实是一个很好的方案，输出的结果也是按顺序输出的

• https://github.com/EDDYCJY/gsema ``` package main

import ( “fmt” “github.com/EDDYCJY/gsema” “math” “time” )

var semaphore = gsema.NewSemaphore(2)

func out(i int){ fmt.Printf(“go func: %d\n”, i) time.Sleep(time.Second) defer semaphore.Done() }

func main() { userCount := math.MaxInt8 for i := 0; i < userCount; i++ { semaphore.Add(1) go out(i) } semaphore.Wait() }

```
go func: 0
go func: 1
go func: 2
go func: 3
go func: 4
go func: 5
go func: 6
go func: 7
go func: 8
go func: 9

协程池

这个就是一次性创建所有的协程，然后再根据大小来调用

• https://github.com/panjf2000/ants

• https://github.com/Jeffail/tunny

  参考

• 来，控制一下 Goroutine 的并发数量