在 go 框架中，限流算法可保护系统免受高并发影响，其中包括：1. 信号量：使用计数器限制并发请求数量，简单易用，但无法动态调整限制；2. 令牌桶：存储固定数量的令牌，平滑请求流量，但配置较复杂；3. 滑动窗口：记录一定时间窗口内的请求数量，动态调整限制，但实现较复杂。根据具体场景选择合适的限流算法至关重要。
Go 框架中的限流算法
在高并发系统中，限流算法至关重要，它可以保护系统免受过载和崩溃的影响。Go 框架内置了多种限流算法，各有优缺点。
1. 信号量
立即学习“go语言免费学习笔记（深入）”；
信号量是一种简单的算法，它使用计数器来限制并发请求的数量。它的优点是简单易用，缺点是不能根据需要动态调整限制。
package main
import (
"context"
"fmt"
"time"
"golang.org/x/time/rate"
)
func main() {
// 创建一个限制每秒 10 个请求的限流器
limiter := rate.NewLimiter(10, 10)
// 获取一个令牌，阻塞直到可用
ctx := context.Background()
if err := limiter.Wait(ctx); err != nil {
fmt.Println(err)
return
}
// 执行受限操作
fmt.Println("受限操作已执行")
}2. 令牌桶
令牌桶是一种更复杂的算法，它存储了一个固定数量的令牌。当需要执行一个请求时，会从桶中取出一枚令牌。如果没有可用的令牌，请求将被阻塞。令牌桶的优点是可以平滑请求流量，缺点是配置较复杂。
package main
import (
"context"
"fmt"
"sync"
"time"
)
type TokenBucket struct {
mu sync.Mutex
tokens int
refillRate int
lastTime time.Time
}
func NewTokenBucket(tokens, refillRate int) *TokenBucket {
return &TokenBucket{
tokens: tokens,
refillRate: refillRate,
lastTime: time.Now(),
}
}
func (b *TokenBucket) Acquire(ctx context.Context) (bool, error) {
b.mu.Lock()
defer b.mu.Unlock()
// 补充令牌
now := time.Now()
b.tokens += int(now.Sub(b.lastTime).Seconds()) * b.refillRate
b.lastTime = now
// 如果令牌已耗尽，阻塞直到可用
for b.tokens <= 0 {
if err := ctx.Err(); err != nil {
return false, err
}
time.Sleep(time.Second)
now = time.Now()
b.tokens += int(now.Sub(b.lastTime).Seconds()) * b.refillRate
b.lastTime = now
}
b.tokens--
return true, nil
}
func main() {
// 创建一个限制每秒 10 个请求的令牌桶
bucket := NewTokenBucket(10, 10)
// 执行受限操作
if ok, err := bucket.Acquire(context.Background()); ok {
fmt.Println("受限操作已执行")
} else {
fmt.Println(err)
}
}3. 滑动窗口
滑动窗口是一个更精确的算法，它记录一定时间窗口内的请求数量。当请求数量超过阈值时，限制将被触发。滑动窗口的优点是可以根据需要动态调整限制，缺点是实现比较复杂。
package main
import (
"context"
"fmt"
"sync"
"time"
)
type SlidingWindow struct {
mu sync.Mutex
window []time.Time
windowSize int
}
func NewSlidingWindow(windowSize int) *SlidingWindow {
return &SlidingWindow{
window: []time.Time{},
windowSize: windowSize,
}
}
func (w *SlidingWindow) Acquire(ctx context.Context) (bool, error) {
w.mu.Lock()
defer w.mu.Unlock()
// 移除窗口之外的请求
for len(w.window) > 0 && w.window[0].Add(time.Duration(w.windowSize)*time.Second).Before(time.Now()) {
w.window = w.window[1:]
}
// 如果窗口已满，阻塞直到可用
for len(w.window) >= w.windowSize {
if err := ctx.Err(); err != nil {
return false, err
}
time.Sleep(time.Second)
}
// 添加新请求到窗口
w.window = append(w.window, time.Now())
return true, nil
}
func main() {
// 创建一个限制每秒 10 个请求的滑动窗口
window := NewSlidingWindow(10)
// 执行受限操作
if ok, err := window.Acquire(context.Background()); ok {
fmt.Println("受限操作已执行")
} else {
fmt.Println(err)
}
}选择合适的限流算法取决于具体场景的具体要求。信号量简单易用，适用于限制并发请求数量。令牌桶可以平滑请求流量，适用于稳定高并发的场景。滑动窗口可以根据需要动态调整限制，适用于对实时性要求较高的场景。
