go限流、计数器固定窗口算法/计数器滑动窗口算法

go限流、计数器固定窗口算法/计数器滑动窗口算法

一、问题

问题1:后端接口只能支撑每10秒1w个请求,要怎么来保护它呢?
问题2:发短信的接口,不超过100次/时,1000次/24小时,要怎么实现?

二、计数器固定窗口算法

所谓固定窗口,就是只设置了一个时间段,给这个时间段加上一个计数器。 常见的就是统计每秒钟的请求量。 这里就是一个QPS计数器。 在这一秒种内的所有请求,只要给这个计数器递增就可以得到当前的并发量了。 用这个方法也就可以解决前面的问题1。可以直接使用系统的当前UNIX时间戳,精确到秒钟。 这个时间戳作为key,设置一个较短的过期时间,比如:10s。

package main

import (
	"fmt"
	"time"
)

type SlidingWindow struct {
	WindowSize        int
	Window            []int
	LastUpdateTime    time.Time
	WindowDuration    time.Duration
	CurrentIndex      int
	Count             int
	MaxAllowedRequest int
}

func NewSlidingWindow(windowSize int, windowDuration time.Duration, maxRequest int) *SlidingWindow {
	if windowSize <= 0 {
		panic("windowSize must be greater than 0")
	}
	return &SlidingWindow{
		WindowSize:        windowSize,
		Window:            make([]int, windowSize),
		LastUpdateTime:    time.Now(),
		WindowDuration:    windowDuration,
		CurrentIndex:      0,
		MaxAllowedRequest: maxRequest,
	}
}

func (sw *SlidingWindow) IncrementCount() {
	now := time.Now()

	if now.Sub(sw.LastUpdateTime) >= sw.WindowDuration { //比较时间是否超过限定时间
		sw.ResetWindow()
	}

	sw.Count++
	sw.Window[sw.CurrentIndex] = sw.Count //窗口总量加1

	if sw.Count > sw.MaxAllowedRequest { //最好用窗口总量去计算。这里为了显示两种效果
		fmt.Println("Max allowed request exceeded")
	}
	sw.CurrentIndex = (sw.CurrentIndex + 1) % sw.WindowSize //窗口往后移动一个位置
}

func (sw *SlidingWindow) ResetWindow() {
	for i := range sw.Window {//将窗口归零
		sw.Window[i] = 0
	}
	sw.Count = 0
	sw.LastUpdateTime = time.Now() //记录最后一次更新
}

func main2() {
	windowSize := 5 //窗口粒度,问题1的话可以简化掉。
	windowDuration := time.Second * 10//十秒的访问量
	maxRequest := 10000//最大访问量

	slidingWindow := NewSlidingWindow(windowSize, windowDuration, maxRequest)

	for i := 0; i < 10; i++ {
		slidingWindow.IncrementCount()
		time.Sleep(time.Second)
	}
}

三、计数器滑动窗口算法

固定窗口就一个计数器,而滑动窗口就需要有多个计数器。 具体需要多少个计数器,要看窗口的范围和粒度来决定窗口大小。 比如:时间窗口的范围是24小时,时间窗口的粒度是1小时,那么窗口大小就是24,需要的计数器也就是24个。 我们再来回顾下前面的问题2。 如果我们用上面的固定窗口算法,需要2个计数器,一个是小时的计数器,一个是24小时,也就是天的计数器。 很明显,天的计数器会有很大的误差。 比如:昨天14点前没有任何请求,然后在14点开始,每小时都有100次请求。 到昨天的23点,刚好用完了1000次全天的额度。 但是这时候,还是每小时有100个请求, 那么从昨天的14点到今天10点,总共20小时就会有2000次请求,远远超过了24小时最多1500次的限制。 所以,这里使用滑动窗口替代固定窗口会更加合适。 如果想要限流控制点更加精准,那么就可以把窗口粒度设计的更细。 而代价就是窗口大小增加,需要的存储和计算量都会增加。 所以,这里也是需要对精准度和成本做平衡和选择,难以兼得。
在这里插入图片描述

package main

import "time"

type RateLimiters struct {
	maxHour  int
	maxDay   int
	lastHour time.Time
	lastDay  time.Time
	hourWin  map[int]int //小时的窗口
}

func GetRateLimiters(hour, day int, first int) *RateLimiters {
	return &RateLimiters{
		maxHour:  hour,
		maxDay:   day,
		lastDay:  time.Now(),
		lastHour: time.Now(),
		hourWin:  make(map[int]int),
	}
}
func (r *RateLimiters) Add() bool {
	now := time.Now()
	if now.Sub(r.lastHour) >= time.Hour { //超过一小时
		if _, ok := r.hourWin[now.Hour()]; ok { //24小时一个轮回,如果轮回到了第一次开始的时间,重新计数
			delete(r.hourWin, now.Hour()) //这里根据需求只清除当前小时,或者所有全部清除(为了计算一天的量)
		}
		r.lastHour = now
	}
	if r.hourWin[now.Hour()] >= r.maxHour { //超出限制返回
		return false
	}
	if now.Sub(r.lastDay) >= 24*time.Hour { //超过24小时
		r.lastDay = now
	}
	if sum(r.hourWin) >= r.maxDay {//遍历小时的数量求当日总和
		return false
	}
	r.hourWin[now.Hour()]++ //增加小时访问量
	return true
}
func sum(m map[int]int) (total int) {
	for _, v := range m {
		total += v
	}
	return total
}
func main() {
	hour := time.Now().Hour()
	rate := GetRateLimiters(100, 1000, hour)
	rate.hourWin[hour] = 0
	rate.dayWin[hour] = 0
	for i := 0; i <= 1000; i++ {
		rate.Add()
	}
}

  • 6
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值