[TOC]

最罕用的限流算法以及如何在 http 中间件中退出流控

何为限流？

通过对并发拜访 / 申请进行限速，或者对一个工夫窗口内的申请进行限速来爱护零碎，一旦达到限度速率则能够拒绝服务、排队或期待、降级等解决

说白了就是限度申请数量，或者是在某一段时间内限度总的申请数量

例如秒杀网站，限度 22 点 5 分 — 22 点 10 分 秒杀 999 份产品，限度放行 5w 个申请，若在该段时间内，申请在第 5w 当前的申请，间接拒之门外，也就是咱们在进入网站的时候显示，零碎忙碌

为什么要限流？

• 后盾服务能力无限，须要限流，否则服务会崩掉
• 能够依据测试性能去评估限流的设置，例如测试最大连接数，qps 数量（每秒钟能解决的最大申请数）
• 避免爬虫、歹意攻打

例如当零碎的访问量忽然剧增，大量的申请涌入过去，咱们可能会晓得会忽然有一波顶峰，这个时候如果服务器接受不了压力的话，就会解体，例如如下几类业务

• 秒杀业务
• 各种刷单
• 微博上的热搜
• 因为某些起因用户猛增，太过激情
• 大量用户（能够是歹意的，也能够是失常的用户量申请过多）高频拜访服务器，服务器承受能力有余
• 网页爬虫 等等

限流个别是如何去实现的？

咱们在某宝或某东的热门节日上剁手，付款的时候，还急咱们怀着焦灼的心期待着排队的人数一个一个降落的时候吗？

咱们在疯狂抢购商品，因为点击太快，激情太高，导致屡次弹出零碎忙碌，请稍后再试，还记得吗？

更有甚者，在流量过大的时候，间接提醒回绝拜访的，这些是不是都一一浮现在脑海呢？

依据如上场景，咱们的限流思路会是这个样子的：

• 拒绝请求
• 设置排队，直到单位申请数趋于失常程度

对于拒绝请求就绝对简略粗犷，对于设置排队就会有多种排队形式了，咱们持续聊

除了限流还有什么形式能够解决或者缓解这种忽然大量申请的状况呢？

还有熔断，降级，都能够无效的解决这样的问题

那啥是降级？

即 服务降级 ，当咱们的服务器压力剧增时，为了保障外围模块的高可用， 这里指的是咱们本身的零碎呈现了故障而降级 ， 有如下 2 个 ** 罕用的解决形式

• 升高非核心模块的性能
• 间接敞开不重要的性能，为保障外围模块的性能失常

如图，某网站，当用户申请数猛增，服务器吃不消的时候，就能够抉择把评论性能，批改明码等性能敞开，确保领取零碎，数据系统等外围性能可能失常运行

哦？那熔断是啥？

与服务降级还是有区别的，这里指的是指依赖的内部接口呈现故障的状况下，会设置断绝和内部接口的关系。

服务器 A 依赖于服务器 B 的对外接口，在某个时刻服务器 B 的接口出现异常，响应工夫极其的慢，可是此接口会影响到服务器的整个运作，那么这个时候，服务器 A 就能够在申请服务器 B 该接口的时候，默认设置返回谬误

最罕用的限流算法

咱们来分享一个最罕用的限流算法，大抵分为以下 4 种

• 固定窗口计数器
• 滑动窗口计数器
• 漏桶
• 令牌桶

固定工夫窗口管制

最简略的是 应用计数器来管制，设置固定的工夫内，解决固定的申请数

上述图，固定工夫窗口来做限度，1 s只能解决 2 个 申请，红色申请则会被间接抛弃

• 固定每 1 秒限度同时申请数为 2
• 上述红色局部的申请会被扔掉，扔掉之后 整个服务负荷可能会升高
• 然而这个会丢掉申请，对于体验不好

滑动窗口计数器算法

可能去平滑一下解决的工作数量。滑动窗口计数器是通过将窗口再细分，并且依照工夫滑动，这种算法防止了固定窗口算法带来的 双倍突发申请，但工夫区间精度越高，算法所需的空间容量越大

• 将工夫划分为多个区间
• 在每个区间内每有一次申请就讲计数器加 1 维持一个工夫窗口，占据多个区间
• 每通过一个区间的工夫，则摈弃最老的一个区间，并纳入最新的一个区间
• 若以后的窗口内区间的申请总数和超过了限度数量，则本窗口内的申请都被抛弃

漏桶

为了解决上述红色局部丢掉的问题，引入了 漏桶的形式进行限流，漏桶是有缓存的，有申请就会放到缓存中

漏桶，听起来有点像漏斗的样子，也是一滴一滴的滴下去的

如图，水滴即为申请的事件，如果漏桶能够缓存 5000 个事件，理论服务器 1s 解决 1000 个事件，那么在高峰期的时候，响应工夫最多等 5 秒，然而不能始终是高峰期，否则，始终响应工夫都是 5s，就会是很慢的工夫了，这个工夫也是很影响体验的

如果桶满了，还有申请过去的话，则会被间接抛弃，这种做法，还是抛弃了申请

• 将每个申请看成 水滴，放入水滴 进行存储
• 漏桶以固定的速率往外漏水，若桶空了则进行漏水。比如说，1s 漏 1000 滴水，正如 1s 解决 1000 个申请
• 如果漏桶慢了，则多余的水滴也会被间接舍弃

劣势

• 有肯定的缓存能力，比上述 2 种形式会好一些

劣势

• 桶满的时候若有新申请，依然会丢掉数据
• 长时间桶满，则会影响响应速率，这个依据桶的大小来定体验是否 ok

令牌桶

通过动态控制令牌的数量，来更好的服务客户端的申请事件，令牌的生成数量和生产速率都是能够灵便管制的

如上，令牌桶和漏桶不同的中央在于

• 令牌桶能够本人管制生成令牌的速率，例如高峰期就能够多生成一些令牌来满足客户端的需要
• 还能够缓存数据

若发现始终是出于高峰期，能够思考扩充令牌桶

劣势

• 令牌桶能够动静的本人管制生成令牌的速率
• 还能够缓存数据

如何在 http middleware 退出流控

如何在 http 中间件中退出流控呢，目标是限流，每一个申请，都须要通过这个中间件，才有机会向后走，才有机会被解决

type middleWareHandler struct {
    r *httprouter.Router
    l *ConnLimiter
}

func NewMiddleWareHandler(r *httprouter.Router, cc int) http.Handler {m := middleWareHandler{}
    m.r = r
    m.l = NewConnLimiter(cc) // 限度数量
    return m
}

说完令牌桶，咱们来说说限流器

限流器

限流器是后盾服务中的十分重要的组件

它能够用做啥呢？

• 限度申请速率

• 爱护服务

  限流器的实现办法有很多种，基本上都是基于上述的限流算法来实现的

• 滑动窗口法
• Token Bucket（令牌桶）
• Leaky Bucket（漏桶）

golang 规范库中就自带了限流算法的实现，不须要咱们本人造轮子

golang.org/x/time/rate，间接用就好了，该限流器是基于 Token Bucket(令牌桶)实现的

令牌桶就是咱们下面说的桶，外面装令牌，零碎会以恒定速率向桶中放令牌

桶满则临时不放。用户申请就要向桶外面拿令牌

• 如果有残余 Token 就能够始终取
• 如果没有残余令牌，则须要等到零碎中被搁置了 Token 才能够往下进行

咱们来看看限流器咋用

结构一个限流对象

limiter := NewLimiter(5, 1);

• 第一个参数是 r Limit，这是代表每秒能够向 令牌桶 中产生多少令牌
• 第二个参数是 b int，这是代表 令牌桶 的容量大小

也就是说，其结构出的限流器是

• 令牌桶大小为 1
• 以每秒 5 个令牌的速率向桶中搁置令牌

咱们当然也能够应用另外的设置形式，包中也有提供

limit := Every(500 * time.Millisecond);
limiter := NewLimiter(limit, 1);

能够用 Every 办法来指定向 Token 桶中搁置令牌的距离，下面代码就示意每 500 ms 往桶中放一个令牌

也就说，上述代码是 1 秒钟，产生 2 个令牌

Limiter是反对能够调整速率和桶大小的，咱们来看看源码

// 扭转放入令牌的速率
SetLimit(Limit) 
// 扭转令牌桶大小
SetBurst(int) 

咱们来写一个案例看看：

package main

import (
    "context"
    "log"
    "time"

    "golang.org/x/time/rate"
)


func main() {l := rate.NewLimiter(1, 2)
    // limit 示意每秒产生 token 数，buret 最多存令牌数
    log.Println(l.Limit(), l.Burst())
    for i := 0; i < 50; i++ {
        // 这里是阻塞期待的，始终等到取到一个令牌为止
        log.Println("... ... Wait")
        c, _ := context.WithTimeout(context.Background(), time.Second*2)
        // Wait 阻塞期待
        if err := l.Wait(c); err != nil {log.Println("limiter wait error :" + err.Error())
        }
        log.Println("Wait  ... ...")

        // Reserve 返回等待时间，再去取令牌
        // 返回须要期待多久才有新的令牌, 这样就能够期待指定工夫执行工作
        r := l.Reserve()
        log.Println("reserve time :", r.Delay())

        // 判断以后是否能够取到令牌
        // Allow 判断以后是否能够取到令牌
        a := l.Allow()
        log.Println("Allow ==", a)
    }
}

看到个数的案例，咱们能够看到，包外面提供给咱们应用的生产办法有 3 种

• Wait

Wait，等于 WaitN(ctx,1)

若此时桶内令牌数组有余 ( 小于 N )，那么 Wait 办法将会阻塞一段时间，直至令牌满足条件，否则就始终阻塞

若满足条件，则间接返回后果

Wait 的 context 参数。能够设置超时工夫

• Allow

看看函数原型

func (lim *Limiter) Allow() bool
func (lim *Limiter) AllowN(now time.Time, n int) bool

Allow 等于 AllowN(time.Now(),1)，以后取一个令牌，若满足，则为 true，否则 false

AllowN办法 指的是，截止到某一时刻，目前桶中令牌数目是否至多为 N 个，满足则返回 true，同时从桶中生产 N 个令牌。反之返回不生产令牌，返回 false

• Reserve

Reserve，等于 ReserveN(time.Now(), 1)

ReserveN 当调用实现后，无论令牌是否短缺，都会返回一个 Reservation* 对象

咱们能够调用该对象的 Delay() 办法，有如下留神：

该办法返回了须要期待的工夫

• 如果等待时间为 0 秒，则阐明不必期待
• 若大于 0 秒，则必须等到等待时间之后，能力向后进行

当然，若不想期待，你能够偿还令牌，一个都不能少，调用该对象的Cancel() 办法即可

总结

• 简略介绍了限流，熔断，服务降级
• 形象分享了限流的 4 种算法
• 介绍了 http 中间件接入流控的简略写法
• 分享了 go golang.org/x/time/rate中，限流器的根本应用

好了，本次就到这里，下一次 互联网协议介绍和分享，

技术是凋谢的，咱们的心态，更应是凋谢的。拥抱变动，背阴而生，致力向前行。

我是 小魔童哪吒，欢送点赞关注珍藏，下次见~