封装一个细粒度的限流器

花椒酱不吃花椒喵

已于 2024-08-13 19:48:09 修改

阅读量392

点赞数 15

分类专栏：工作项目梳理文章标签：经验分享

于 2024-08-13 00:12:44 首次发布

本文链接：https://blog.csdn.net/Mengbabe_2018/article/details/141098492

版权

工作项目梳理专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章目录

原因
限流对象
限流后的做法
四种静态限流算法
手写限流算法
分布式限流的具体实现

原因

尽管云原生网关里有统一入口的限流（根据ip、userID来控制），但是有的微服务需要有自己的限流策略（比如根据不同的算法任务、不同的子产品来限制），所以封装了一个限流器公共包，可以在多个微服务中复用这个功能。直接原因是有一次某个子功能流量激增，大量任务失败。

关键步骤：

实现限流策略，例如基于令牌桶或漏桶
配置和初始化，微服务启动时加载配置和初始化限流器

限流对象

针对ip限流，例如1s限制50个请求，考虑到公共ip的情况；
针对某个算法任务，不限制vip用户，普通用户1s限制创建10个创建任务的请求。

限流后的做法

目前的做法是限流了就直接拒绝，抛出错误提示，还有其他的做法:

同步阻塞等待一段时间。如果是偶发性地触发了限流，那么稍微阻塞等待一会儿，后面就有极大的概率能得到处理。比如说限流设置为一秒钟 100 个请求，恰好来了 101 个请求。多出来的一个请求只需要等一秒钟，下一秒钟就会被处理。但是要注意控制住超时，也就是说你不能让人无限期地等待下去。
同步转异步。这里我们又一次看到了这个手段，它是指如果一个请求没被限流，那就直接同步处理；而如果被限流了，那么这个请求就会被存储起来，等到业务低峰期的时候再处理。这个其实跟降级差不多。（TODO 研究到降级时再过来看一下）
-调整负载均衡算法（用redis的话似乎跟负载均衡没关系，如果是在网关里做限流是可以调整负载均衡器的）。如果某个请求被限流了，那么就相当于告诉负载均衡器，应该尽可能少给这个节点发送请求。我在熔断里面给你讲过类似的方案。不过在熔断里面是负载均衡器后续不再发请求，而在限流这里还是会发送请求，只是会降低转发请求到该节点的概率。调整节点的权重就能达成这种效果。

四种静态限流算法

令牌桶

系统会以一个恒定的速率产生令牌，这些令牌会放到一个桶里面，每个请求只有拿到了令牌才会被执行。每当一个请求过来的时候，就需要尝试从桶里面拿一个令牌。如果拿到了令牌，那么请求就会被处理；如果没有拿到，那么这个请求就被限流了。（当令牌桶已满时，新生成的令牌会被丢弃，不会增加桶中的令牌数量。）
你需要注意，本身令牌桶是可以积攒一定数量的令牌的。比如说桶的容量是 100，也就是这里面最多积攒 100 个令牌。那么当某一时刻突然来了 100 个请求，它们都能拿到令牌。
在这里插入图片描述

漏桶

漏桶是指当请求以不均匀的速度到达服务器之后，限流器会以固定的速率转交给业务逻辑。
某种程度上，你可以将漏桶算法看作是令牌桶算法的一种特殊形态。你将令牌桶中桶的容量设想为 0，就是漏桶了。
在这里插入图片描述

所以你可以看到，在漏桶里面，令牌产生之后你就需要取走，没取走的话也不会积攒下来。因此漏桶是绝对均匀的，而令牌桶不是绝对均匀的。

固定窗口与滑动窗口

固定窗口是指在一个固定时间段，只允许执行固定数量的请求。比如说在一秒钟之内只能执行 100 个请求。滑动窗口类似于固定窗口，也是指在一个固定时间段内，只允许执行固定数量的请求。区别就在于，滑动窗口是平滑地挪动窗口，而不像固定窗口那样突然地挪动窗口。假设窗口大小是一分钟。此时时间是 t1，那么窗口的起始位置是 t1-1 分钟。过了 2 秒之后，窗口大小依旧是 1 分钟，但是窗口的起始位置也向后挪动了 2 秒，变成了 t1 - 1 分钟 + 2 秒。这也就是滑动的含义。
在这里插入图片描述

手写限流算法

https://blog.csdn.net/z3551906947/article/details/140477024

https://blog.51cto.com/u_15840568/5784049
参考：
https://www.jb51.net/jiaoben/284808pef.htm

令牌桶

package limiter

import (
    "sync"
    "time"
)

// TokenBucketLimiter 令牌桶限流器
type TokenBucketLimiter struct {
    capacity      int        // 容量
    currentTokens int        // 令牌数量
    rate          int        // 发放令牌速率/秒
    lastTime      time.Time  // 上次发放令牌时间
    mutex         sync.Mutex // 避免并发问题
}

// NewTokenBucketLimiter 创建一个新的令牌桶限流器实例。
func NewTokenBucketLimiter(capacity, rate int) *TokenBucketLimiter {
    return &TokenBucketLimiter{
       capacity:      capacity,
       rate:          rate,
       lastTime:      time.Now(),
       currentTokens: 0, // 初始化时桶中没有令牌
    }
}

// TryAcquire 尝试从令牌桶中获取一个令牌。
func (l *TokenBucketLimiter) TryAcquire() bool {
    l.mutex.Lock()
    defer l.mutex.Unlock()

    now := time.Now()
    interval := now.Sub(l.lastTime) // 计算时间间隔

    // 如果距离上次发放令牌超过 1/rate 秒，则发放新的令牌
    if float64(interval) >= float64(time.Second)/float64(l.rate) {
       // 计算应该发放的令牌数量，但不超过桶的容量
       newTokens := int(float64(interval)/float64(time.Second)* l.rate) 
       l.currentTokens = minInt(l.capacity, l.currentTokens+newTokens)

       // 更新上次发放令牌的时间
       l.lastTime = now
    }

    // 如果桶中没有令牌，则请求失败
    if l.currentTokens == 0 {
       return false
    }

    // 桶中有令牌，消费一个令牌
    l.currentTokens--

    return true
}

// minInt 返回两个整数中的较小值。
func minInt(a, b int) int {
    if a < b {
       return a
    }
    return b
}

func TestName(t *testing.T) {
    tokenBucket := NewTokenBucketLimiter(5, 10)
    for i := 0; i < 10; i++ {
        fmt.Println(tokenBucket.TryAcquire())
    }
    time.Sleep(100 * time.Millisecond)
    fmt.Println(tokenBucket.TryAcquire())
}

漏桶

package limiter

import (
	"fmt"
	"math"
	"sync"
	"testing"
	"time"
)

// LeakyBucketLimiter 漏桶限流器
type LeakyBucketLimiter struct {
	capacity     int        // 桶容量
	currentLevel int        // 当前水位
	rate         int        // 水流速度/秒
	lastTime     time.Time  // 上次放水时间
	mutex        sync.Mutex // 避免并发问题
}

// NewLeakyBucketLimiter 初始化漏桶限流器
func NewLeakyBucketLimiter(capacity, rate int) *LeakyBucketLimiter {
	return &LeakyBucketLimiter{
		capacity:     capacity,
		currentLevel: 0, // 初始化时水位为0
		rate:         rate,
		lastTime:     time.Now(),
	}
}

// TryAcquire 尝试获取处理请求的权限
func (l *LeakyBucketLimiter) TryAcquire() bool {
	l.mutex.Lock() // 直接获取写锁
	defer l.mutex.Unlock()

	// 如果上次放水时间距今不到 1/rate 秒，不需要放水
	now := time.Now()
	interval := now.Sub(l.lastTime)

	// 计算放水后的水位
	if float64(interval) >= float64(time.Second)/float64(l.rate) {
		l.currentLevel = int(math.Max(0, float64(l.currentLevel)-float64(interval)/float64(time.Second)*float64(l.rate)))
		l.lastTime = now
	}
	// 尝试增加水位
	if l.currentLevel < l.capacity {
		l.currentLevel++
		return true
	}
	return false
}

func TestName(t *testing.T) {
	tokenBucket := NewLeakyBucketLimiter(5, 10)
	for i := 0; i < 10; i++ {
		fmt.Println(tokenBucket.TryAcquire())
	}
	time.Sleep(100 * time.Millisecond)
	fmt.Println(tokenBucket.TryAcquire())
}

固定窗口

package main

import (
	"sync"
	"time"
)

// FixedWindowRateLimiter 定义固定窗口限流器
type FixedWindowRateLimiter struct {
	mu           sync.Mutex
	maxRequests  int
	requestCount int
	window       time.Time // 窗口的起始点，每个窗口长度1s
}

// NewFixedWindowRateLimiter 创建一个新的固定窗口限流器实例
func NewFixedWindowRateLimiter(maxRequests int) *FixedWindowRateLimiter {
	return &FixedWindowRateLimiter{
		maxRequests: maxRequests,
		window:      time.Now().Truncate(time.Second),
	}
}

// TryAcquire 尝试获取请求许可
func (f *FixedWindowRateLimiter) TryAcquire() bool {
	f.mu.Lock()
	defer f.mu.Unlock()

	// 检查是否需要重置窗口
	if time.Now().After(f.window.Add(time.Second)) {
		f.requestCount = 0
		f.window = time.Now().Truncate(time.Second)
	}

	// 检查是否达到最大请求次数
	if f.requestCount >= f.maxRequests {
		return false
	}

	// 请求成功，递增计数器
	f.requestCount++
	return true
}

func main() {
	limiter := NewFixedWindowRateLimiter(5)
	for i := 0; i < 10; i++ {
		if limiter.TryAcquire() {
			fmt.Println("请求通过")
		} else {
			fmt.Println("请求被拒绝")
		}
		time.Sleep(100 * time.Millisecond)
	}
}

滑动窗口

package main

import (
	"sync"
	"time"
)

// SlidingWindowRateLimiter 定义滑动窗口限流器
type SlidingWindowRateLimiter struct {
	mu           sync.Mutex
	maxRequests  int
	windowSize   time.Duration
	windows      []int
	windowIndex  int
	currentTime  time.Time
}

// NewSlidingWindowRateLimiter 创建一个新的滑动窗口限流器实例
func NewSlidingWindowRateLimiter(maxRequests int, windowSize time.Duration) *SlidingWindowRateLimiter {
	numWindows := int(windowSize.Seconds())
	return &SlidingWindowRateLimiter{
		maxRequests:  maxRequests,
		windowSize:   windowSize,
		windows:      make([]int, numWindows),
		currentTime:  time.Now().Truncate(time.Second),
		windowIndex:  0,
	}
}

// TryAcquire 尝试获取请求许可
func (s *SlidingWindowRateLimiter) TryAcquire() bool {
	s.mu.Lock()
	defer s.mu.Unlock()

	// 更新当前时间
	currentTime := time.Now().Truncate(time.Second)

	// 检查是否需要更新窗口
	if currentTime.After(s.currentTime.Add(s.windowSize)) {
		s.currentTime = currentTime
		s.windowIndex = 0
	} else if currentTime.After(s.currentTime.Add(time.Second)) {
		s.windowIndex = (s.windowIndex + 1) % len(s.windows)
	}

	// 清除过期窗口
	for i := range s.windows {
		if currentTime.Before(s.currentTime.Add(time.Duration(i+1)*time.Second)) {
			break
		}
		s.windows[i] = 0
	}

	// 检查是否达到最大请求次数
	totalRequests := 0
	for _, count := range s.windows {
		totalRequests += count
	}
	if totalRequests >= s.maxRequests {
		return false
	}

	// 请求成功，递增计数器
	s.windows[s.windowIndex]++
	return true
}

func main() {
	limiter := NewSlidingWindowRateLimiter(5, 10*time.Second)
	for i := 0; i < 10; i++ {
		if limiter.TryAcquire() {
			fmt.Println("请求通过")
		} else {
			fmt.Println("请求被拒绝")
		}
		time.Sleep(100 * time.Millisecond)
	}
}

分布式限流的具体实现

从单机或者集群的角度看，可以分为单机限流或者集群限流。集群限流一般需要借助 Redis 之类的中间件来记录流量和阈值。换句话说，就是你需要用 Redis 等工具来实现前面提到的限流算法。当然如果是利用网关来实现集群限流，那么可以摆脱 Redis。

花椒酱不吃花椒喵

关注

15
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
封装一个细粒度的限流器

尽管云原生网关里有统一入口的限流（根据ip、userID来控制），但是有的微服务需要有自己的限流策略（比如根据不同的算法任务、不同的子产品来限制），所以封装了一个限流器公共包，可以在多个微服务中复用这个功能。直接原因是有一次某个子功能流量激增，大量任务失败。
复制链接

扫一扫

专栏目录