go控制并发数

package main
 
import (
    "fmt"
    "log"
    "sync"
    "time"
)
 
type Glimit struct {
    n int
    c chan struct{}
}
 
// 初始化Glimit结构体
func New_workers(max_goroutine int) (*Glimit, error) {
    if max_goroutine <= 0 {
        return nil, fmt.Errorf("max_goroutine must be greater than 0")
    }
    return &Glimit{
        n: max_goroutine,
        c: make(chan struct{}, max_goroutine),
    }, nil
}
 
// 在限制内运行f函数
func (g *Glimit) Run(f func() error) {
    wg.Add(1)
    g.c <- struct{}{} // 阻塞直到有空闲槽位
    go func() {
 
        defer func() {
            if r := recover(); r != nil {
                log.Printf("panic occurred in goroutine with msg : %v", r)
            }
            //log.Println(`通道被释放`)
            <-g.c
            wg.Done()
        }()
 
        if err := f(); err != nil {
            log.Printf("Function execution failed  with error: %v", err)
        }
    }()
}
 
var wg = sync.WaitGroup{}
 
func main() {
    number := 8
    g, err := New_workers(3) // 定义一次最多使用3个并发
    if err != nil {
        log.Fatalf("Failed to initialize Glimit: %v", err)
    }
 
    for i := 0; i < number; i++ {
 
        value := i // value只在for循环体里有效
        // 在循环里定义每次要执行的函数
        goFunc := func() error {
 
            // 做一些业务逻辑处理
            log.Printf(" %v go func: %d \n", time.Now(), value)
            //  time.Sleep(time.Second)
            // 模拟一个可能发生的错误
            if value == 5 {
 
                return fmt.Errorf("simulated error at value: %d", value)
                //panic(fmt.Errorf("simulated error at value: %d", value))
            }
            return nil
        }
        g.Run(goFunc)
    }
    wg.Wait() // 等待结束
    log.Println("ALL DONE!")
 
}