package golimit

type GoLimit struct {
    ch chan int
}
func NewGoLimit(max int) *GoLimit {
    return &GoLimit{ch: make(chan int, max)}
func (g *GoLimit) Add() {
    g.ch <- 1
func (g *GoLimit) Done() {
    <-g.ch

package main

import (
    "golimit"
    "log"
    "time"
)
func main() {
    log.Println("開始測試...")
    g := golimit.NewGoLimit(2) //max_num(最大允許并發(fā)數(shù))設(shè)置為2
    for i := 0; i < 10; i++ {
        //嘗試增加一個(gè)協(xié)程, 若已達(dá)到最大并發(fā)數(shù),將阻塞
        g.Add()
        go func(g *golimit.GoLimit, i int) {
            defer g.Done() //一個(gè)并發(fā)協(xié)程已經(jīng)完成
            time.Sleep(time.Second * 2)
            log.Println(i, "done")
        }(g, i)
    }
    log.Println("循環(huán)結(jié)束")
    time.Sleep(time.Second * 3)//等待執(zhí)行完成
    log.Println("測試結(jié)束")
}

// 協(xié)程并發(fā)數(shù)限制庫
package golimit
import (
    "sync"
)
type GoLimit struct {
    max       uint             //并發(fā)最大數(shù)量
    count     uint             //當(dāng)前已有并發(fā)數(shù)
    isAddLock bool             //是否已鎖定增加
    zeroChan  chan interface{} //為0時(shí)廣播
    addLock   sync.Mutex       //(增加并發(fā)數(shù)的)鎖
    dataLock  sync.Mutex       //(修改數(shù)據(jù)的)鎖
}
func NewGoLimit(max uint) *GoLimit {
    return &GoLimit{max: max, count: 0, isAddLock: false, zeroChan: nil}
}
//并發(fā)計(jì)數(shù)加1.若 計(jì)數(shù)>=max_num, 則阻塞,直到 計(jì)數(shù)<max_num
func (g *GoLimit) Add() {
    g.addLock.Lock()
    g.dataLock.Lock()
    g.count += 1
    if g.count < g.max { //未超并發(fā)時(shí)解鎖,后續(xù)可以繼續(xù)增加
        g.addLock.Unlock()
    } else { //已到最大并發(fā)數(shù), 不解鎖并標(biāo)記. 等數(shù)量減少后解鎖
        g.isAddLock = true
    }
    g.dataLock.Unlock()
}
//并發(fā)計(jì)數(shù)減1
//若計(jì)數(shù)<max_num, 可以使原阻塞的Add()快速解除阻塞
func (g *GoLimit) Done() {
    g.dataLock.Lock()
    g.count -= 1
    //解鎖
    if g.isAddLock == true && g.count < g.max {
        g.isAddLock = false
        g.addLock.Unlock()
    }
    //0廣播
    if g.count == 0 && g.zeroChan != nil {
        close(g.zeroChan)
        g.zeroChan = nil
    }
    g.dataLock.Unlock()
}
//更新最大并發(fā)計(jì)數(shù)為, 若是調(diào)大, 可以使原阻塞的Add()快速解除阻塞
func (g *GoLimit) SetMax(n uint) {
    g.dataLock.Lock()
    g.max = n
    //解鎖
    if g.isAddLock == true && g.count < g.max {
        g.isAddLock = false
        g.addLock.Unlock()
    }
    //加鎖
    if g.isAddLock == false && g.count >= g.max {
        g.isAddLock = true
        g.addLock.Lock()
    }
    g.dataLock.Unlock()
}
//若當(dāng)前并發(fā)計(jì)數(shù)為0, 則快速返回; 否則阻塞等待,直到并發(fā)計(jì)數(shù)為0
func (g *GoLimit) WaitZero() {
    g.dataLock.Lock()
    //無需等待
    if g.count == 0 {
        g.dataLock.Unlock()
        return
    }
    //無廣播通道, 創(chuàng)建一個(gè)
    if g.zeroChan == nil {
        g.zeroChan = make(chan interface{})
    }
    //復(fù)制通道后解鎖, 避免從nil讀數(shù)據(jù)
    c := g.zeroChan
    g.dataLock.Unlock()
    <-c
}
//獲取并發(fā)計(jì)數(shù)
func (g *GoLimit) Count() uint {
    return g.count
}
//獲取最大并發(fā)計(jì)數(shù)
func (g *GoLimit) Max() uint {
    return g.max
}

package main
import (
    "github.com/zh-five/golimit"
    "log"
    "time"
)
func main() {
    log.Println("開始測試...")
    g := golimit.NewGoLimit(2) //max_num(最大允許并發(fā)數(shù))設(shè)置為2
    for i := 0; i < 10; i++ {
        //并發(fā)計(jì)數(shù)加1.若 計(jì)數(shù)>=max_num, 則阻塞,直到 計(jì)數(shù)<max_num
        g.Add()
        //運(yùn)行過程中可以隨時(shí)修改最大可并發(fā)數(shù)據(jù)
        //g.SetMax(3)
        go func(g *golimit.GoLimit, i int) {
            defer g.Done() //并發(fā)計(jì)數(shù)減1
            time.Sleep(time.Second * 2)
            log.Println(i, "done")
        }(g, i)
    }
    log.Println("循環(huán)結(jié)束")
    g.WaitZero() //阻塞, 直到所有并發(fā)都完成
    log.Println("測試結(jié)束")
}