[每周一更]-(第92期)：Go项目中的限流算法

这周五在清明假期内，提前更新文章

很多业务会有限流的场景，比如活动秒杀、社区搜索查询、社区留言功能；保护自身系统和下游系统不被巨型流量冲垮等。

在计算机网络中，限流就是控制网络接口发送或接收请求的速率，它可防止DoS攻击和限制Web爬虫。

限流，也称流量控制。是指系统在面临高并发，或者大流量请求的情况下，限制新的请求对系统的访问，从而保证系统的稳定性。限流会导致部分用户请求处理不及时或者被拒，这就影响了用户体验。所以一般需要在系统稳定和用户体验之间平衡一下。

一、场景

Go语言的限流场景非常广泛，适用于各种需要控制访问速率的场景。以下是一些常见的限流场景：

• API服务限流： 假设你正在开发一个API服务，你可以使用限流来限制对API端点的访问速率，以防止恶意攻击或过度使用API。例如，你可以限制每个IP地址的请求速率，或者根据API密钥对用户进行限流。
• Web爬虫控制： 如果你正在开发一个网络爬虫，你可能需要限制爬取网站的速率，以避免对目标网站造成过大的负担。你可以使用限流来控制爬取速率，以免被目标网站封禁IP地址。
• 消息队列消费者： 在处理消息队列时，你可能需要控制消费者的处理速率，以防止过度消费消息。你可以使用限流来控制消费者从消息队列中拉取消息的速率，确保系统稳定运行。
• 数据库访问限流： 在高并发的情况下，数据库可能成为瓶颈。你可以使用限流来控制对数据库的并发访问，以避免数据库超载或数据库连接池耗尽。
• RPC调用限流： 如果你的应用程序依赖于其他服务的RPC调用，你可能需要限制对RPC服务的调用速率，以避免对目标服务造成过大的负荷或超出服务提供商的配额。
• 任务调度： 控制任务调度器并发执行任务的速率，以避免过度消耗系统资源或超出服务协议。
• 文件IO： 控制对文件系统的读写操作，以避免过度消耗系统资源。

二、常用算法

限流算法用于控制系统的流量，防止系统被过载。

• 令牌桶算法（Token Bucket Algorithm）： 令牌桶算法是一种基于令牌桶的限流算法。在这个算法中，有一个固定容量的桶，以固定的速率往桶里添加令牌。每当有请求到来时，必须从桶中获取一个令牌，如果桶中没有足够的令牌，则拒绝该请求或等待直到有足够的令牌为止。
• 漏桶算法（Leaky Bucket Algorithm）： 漏桶算法是一种基于漏桶的限流算法。在这个算法中，有一个固定容量的漏桶，以固定的速率漏水。每当有请求到来时，将请求放入漏桶中，如果漏桶已满，则拒绝该请求；否则，请求在漏桶中等待一段时间后被处理。
• 计数器算法（Counter Algorithm）也叫固定窗口算法： 计数器算法是一种简单的限流算法。在这个算法中，统计一定时间窗口内的请求次数，如果请求次数超过了设定的阈值，则拒绝后续的请求。
• 滑动窗口算法（Sliding Window Algorithm）： 滑动窗口算法是一种动态调整窗口大小的限流算法。在这个算法中，统计一定时间窗口内的请求次数，如果请求次数超过了设定的阈值，则拒绝后续的请求。与计数器算法不同的是，滑动窗口算法可以动态调整时间窗口的大小，适应不同的流量变化。

以下看下各个算法的图及示例：

2.1、令牌桶算法

package main

import (
	"time"

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

func main() {
	// 创建一个令牌桶，每秒产生3个令牌
	limiter := rate.NewLimiter(3, 1)

	// 模拟10次请求
	for i := 0; i < 10; i++ {
		// 获取一个令牌，如果没有可用的令牌则阻塞等待
		limiter.WaitN(time.Now(), 1)
		// 处理请求
		handleRequest()
	}
}

func handleRequest() {
	// 模拟处理请求
	println("Handling request...")
}

2.2、漏桶算法

package main

import (
	"time"
)

func main() {
	// 创建一个容量为3的漏桶，每秒漏水1个
	limiter := NewLeakyBucket(3, 1)

	// 模拟10次请求
	for i := 0; i < 10; i++ {
		// 获取一个漏桶令牌，如果漏桶已满则阻塞等待
		limiter.Wait()
		// 处理请求
		handleRequest()
	}
}

func handleRequest() {
	// 模拟处理请求
	println("Handling request...")
}

// 漏桶结构体
type LeakyBucket struct {
	capacity   int           // 漏桶容量
	rate       time.Duration // 漏桶速率
	lastLeak   time.Time     // 上一次漏水时间
	dripAmount int           // 漏水数量
}

// 创建一个新的漏桶
func NewLeakyBucket(capacity int, ratePerSecond int) *LeakyBucket {
	return &LeakyBucket{
		capacity:   capacity,
		rate:       time.Second / time.Duration(ratePerSecond),
		lastLeak:   time.Now(),
		dripAmount: 0,
	}
}

// 获取一个漏桶令牌，如果漏桶已满则阻塞等待
func (lb *LeakyBucket) Wait() {
	now := time.Now()
	// 计算自上一次漏水以来应该漏掉的数量
	lb.dripAmount += int(now.Sub(lb.lastLeak) / lb.rate)
	// 如果漏桶溢满，等待一段时间
	if lb.dripAmount > lb.capacity {
		time.Sleep(lb.rate)
	}
	// 更新上一次漏水时间
	lb.lastLeak = now
	// 漏水一个令牌
	lb.dripAmount--
}

2.3、计数器算法

package main

import (
	"time"
)

func main() {
	// 创建一个计数器限流器，每秒最多处理3个请求
	limiter := NewCounterLimiter(3, time.Second)

	// 模拟10次请求
	for i := 0; i < 10; i++ {
		// 判断是否允许进行请求
		if limiter.Allow() {
			// 处理请求
			handleRequest()
		} else {
			// 请求被限流，打印提示信息
			println("Request limited, please try again later.")
		}
	}
}

func handleRequest() {
	// 模拟处理请求
	println("Handling request...")
}

// 计数器限流器结构体
type CounterLimiter struct {
	counter    int           // 当前计数器值
	limit      int           // 计数器限制
	interval   time.Duration // 时间间隔
	lastUpdate time.Time     // 上次更新时间
}

// 创建一个新的计数器限流器
func NewCounterLimiter(limit int, interval time.Duration) *CounterLimiter {
	return &CounterLimiter{
		counter:    0,
		limit:      limit,
		interval:   interval,
		lastUpdate: time.Now(),
	}
}

// 判断是否允许进行请求
func (limiter *CounterLimiter) Allow() bool {
	// 更新计数器值
	limiter.updateCounter()
	// 判断计数器值是否超过限制
	if limiter.counter >= limiter.limit {
		return false
	}
	// 计数器值加1，表示处理一个请求
	limiter.counter++
	return true
}

// 更新计数器值
func (limiter *CounterLimiter) updateCounter() {
	// 计算距离上次更新的时间间隔
	interval := time.Since(limiter.lastUpdate)
	// 如果时间间隔大于限定的间隔，则重置计数器
	if interval >= limiter.interval {
		limiter.counter = 0
		limiter.lastUpdate = time.Now()
	}
}

2.4、滑动窗口算法

package main

import (
	"time"
)

func main() {
	// 初始化一个滑动窗口限流器，窗口大小为1秒，允许的请求数为3
	limiter := NewSlidingWindowLimiter(3, 1*time.Second)

	// 模拟10次请求
	for i := 0; i < 10; i++ {
		// 判断是否允许进行请求，如果超过限制则等待
		for !limiter.Allow() {
			time.Sleep(time.Millisecond * 100)
		}
		// 处理请求
		handleRequest()
	}
}

func handleRequest() {
	// 模拟处理请求
	println("Handling request...")
}

// 滑动窗口限流器结构体
type SlidingWindowLimiter struct {
	requests []time.Time // 存储每个请求的时间戳
	limit    int         // 允许的请求数
	interval time.Duration // 时间窗口大小
}

// 创建一个新的滑动窗口限流器
func NewSlidingWindowLimiter(limit int, interval time.Duration) *SlidingWindowLimiter {
	return &SlidingWindowLimiter{
		requests: make([]time.Time, 0),
		limit:    limit,
		interval: interval,
	}
}

// 判断是否允许进行请求
func (limiter *SlidingWindowLimiter) Allow() bool {
	// 移除时间窗口外的请求
	for len(limiter.requests) > 0 && time.Since(limiter.requests[0]) > limiter.interval {
		limiter.requests = limiter.requests[1:]
	}
	// 如果请求数超过限制，则拒绝请求
	if len(limiter.requests) >= limiter.limit {
		return false
	}
	// 记录当前请求时间
	limiter.requests = append(limiter.requests, time.Now())
	return true
}

在Go语言中，可以使用一些库来实现限流，例如：

Go 在 x 标准库，即 golang.org/x/time/rate 里自带了一个限流器，这个限流器是基于令牌桶算法（token bucket）实现的。

• github.com/juju/ratelimit：提供基于令牌桶算法的限流实现。
• github.com/golang/groupcache：提供的并发访问控制工具可以用于限制对共享资源的并发访问。
• github.com/uber-go/ratelimit：提供了令牌桶和漏桶算法的实现，支持更复杂的限流策略。

三、优缺点对比

这四种限流算法各有优缺点，简要的比较：

1. 令牌桶算法：
   • 优点：
     • 令牌桶算法可以在令牌足够的情况下，突发地处理一定数量的请求。
     • 算法简单，容易实现。
   • 缺点：
     • 实现相对复杂，需要维护令牌桶的状态。
     • 无法应对突发流量，因为在令牌桶为空时无法处理任何请求。
2. 漏桶算法：
   • 优点：
     • 漏桶算法可以对突发流量进行平滑处理，稳定输出。
     • 算法简单，容易实现。
   • 缺点：
     • 无法应对突发流量，因为漏桶已满时无法处理任何请求。
     • 对于突发流量的应对能力较弱。
3. 计数器算法（固定窗口算法）：
   • 优点：
     • 计数器算法简单直观，易于实现。
     • 可以精确控制单位时间内的请求量。
   • 缺点：
     • 对于突发流量的应对能力较弱，无法动态调整限流窗口。
     • 无法应对突发流量，因为在计数器达到限制后无法处理任何请求。
4. 滑动窗口算法：
   • 优点：
     • 滑动窗口算法可以动态调整限流窗口的大小，适应不同的流量情况。
     • 对于突发流量的应对能力较强。
   • 缺点：
     • 算法相对复杂，实现较为困难。
     • 需要维护窗口中的请求记录，可能会消耗较多的内存。

四、参考

• x_rate
• go-zero_limiter示例+压测
• (微服务)服务治理：几种开源限流算法库/应用软件介绍和使用
• 令牌桶算法限流
• 常见限流算法