golang高并发系统限流策略漏桶和令牌桶算法源码剖析_Golang_

// 定义全局限流器对象 var rateLimit ratelimit.Limiter // 在 gin.HandlerFunc 加入限流逻辑 func leakyBucket() gin.HandlerFunc { prev := time.Now() return func(c *gin.Context) { now := rateLimit.Take() fmt.Println(now.Sub(prev)) // 为了打印时间间隔 prev = now // 记录上一次的时间，没有这个打印的会有问题 } } func main() { rateLimit = ratelimit.New(10) r := gin.Default() r.GET("/ping", leakyBucket(), func(c *gin.Context) { c.JSON(200, true) }) r.Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080") } 

type limiter struct { sync.Mutex last time.Time sleepFor time.Duration perRequest time.Duration maxSlack time.Duration clock Clock } type Limiter interface { // Take should block to make sure that the RPS is met. Take() time.Time } 

l := &limiter{ perRequest: time.Second / time.Duration(rate), maxSlack: -10 * time.Second / time.Duration(rate), } 

func (t *limiter) Take() time.Time { t.Lock() defer t.Unlock() now := t.clock.Now() if t.last.IsZero() { t.last = now return t.last } t.sleepFor += t.perRequest - now.Sub(t.last) if t.sleepFor < t.maxSlack { t.sleepFor = t.maxSlack } if t.sleepFor > 0 { t.clock.Sleep(t.sleepFor) t.last = now.Add(t.sleepFor) t.sleepFor = 0 } else { t.last = now } return t.last } 

import ( "net/http" "time" "github.com/gin-gonic/gin" "golang.org/x/time/rate" ) var rateLimit *rate.Limiter func tokenBucket() gin.HandlerFunc { return func(c *gin.Context) { if rateLimit.Allow() { c.String(http.StatusOK, "rate limit,Drop") c.Abort() return } c.Next() } } func main() { limit := rate.Every(100 * time.Millisecond) rateLimit = rate.NewLimiter(limit, 10) r := gin.Default() r.GET("/ping", tokenBucket(), func(c *gin.Context) { c.JSON(200, true) }) r.Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080") } 

type Limit float64 // Inf is the infinite rate limit; it allows all events (even if burst is zero). const Inf = Limit(math.MaxFloat64) // Every converts a minimum time interval between events to a Limit. func Every(interval time.Duration) Limit { if interval <= 0 { return Inf } return 1 / Limit(interval.Seconds()) } 

type Limiter struct { mu sync.Mutex limit Limit burst int tokens float64 // last is the last time the limiter's tokens field was updated last time.Time // lastEvent is the latest time of a rate-limited event (past or future) lastEvent time.Time } 

type Reservation struct { ok bool lim *Limiter tokens int timeToAct time.Time // This is the Limit at reservation time, it can change later. limit Limit } 

func (lim *Limiter) advance(now time.Time) (newNow time.Time, newLast time.Time, newTokens float64) { //last不能在当前时间now之后，否则计算出来的elapsed为负数，会导致令牌桶数量减少 last := lim.last if now.Before(last) { last = now } //根据令牌桶的缺数计算出令牌桶未进行更新的最大时间 maxElapsed := lim.limit.durationFromTokens(float64(lim.burst) - lim.tokens) elapsed := now.Sub(last) //令牌桶未进行更新的时间段 if elapsed > maxElapsed { elapsed = maxElapsed } //根据未更新的时间(未向桶中加入令牌的时间段)计算出产生的令牌数 delta := lim.limit.tokensFromDuration(elapsed) tokens := lim.tokens + delta //计算出可用的令牌数 if burst := float64(lim.burst); tokens > burst { tokens = burst } return now, last, tokens } 

// @param n 要消费的token数量 // @param maxFutureReserve 愿意等待的最长时间 func (lim *Limiter) reserveN(now time.Time, n int, maxFutureReserve time.Duration) Reservation { lim.mu.Lock() // 如果没有限制 if lim.limit == Inf { lim.mu.Unlock() return Reservation{ ok: true,
                
提示：
                    本文由神整理自网络，如有侵权请联系本站删除！
                    

                    本站声明： 

                    1、本站所有资源均来源于互联网，不保证100%完整、不提供任何技术支持； 

                    2、本站所发布的文章以及附件仅限用于学习和研究目的;不得将用于商业或者非法用途；否则由此产生的法律后果，本站概不负责！
                
                

                

                                            
上一篇：Go实现分布式系统高可用限流器实战_Golang_
                                                                
下一篇：Go modules replace解决Go依赖引用问题_Golang_