限流算法学习

限流算法

限流算法是在系统设计中常用来控制资源访问速率、防止服务过载的技术手段。

基本介绍

主要的限流算法有以下几种：

1. 计数器算法
   计数器算法是最简单的限流算法，它在一个时间窗口内统计请求次数，如果请求次数超过了设定的阈值，则拒绝服务。这种方法实现简单，但存在时间窗口切换时的瞬间流量突增问题。
2. 滑动窗口算法
   滑动窗口算法是对计数器算法的改进，它将时间窗口分成多个小的窗口，通过维护这些小窗口的计数，可以更平滑地控制流量。这种算法可以较好地解决计数器算法中存在的突增问题。
3. 令牌桶算法
   令牌桶算法通过一个固定容量的令牌桶来控制流量，系统以恒定速率往桶中添加令牌，处理请求时需要从桶中取出令牌，如果桶中没有令牌，则拒绝服务。这种算法可以允许一定程度的突发流量，因为桶中可以积累令牌。
4. 漏桶算法
   漏桶算法将请求放入到一个固定容量的桶中，系统以恒定的速率从桶中取出请求进行处理。如果桶满了，则新进的请求会被丢弃或排队等待。这种算法可以很好地控制数据的平均速率和突发速率。

适用场景

计数器算法

特点：简单直接，通过在固定的时间窗口内计数并限制请求的数量来实现限流。

​ 适用场景：

​ 适用于单一服务实例的场景。

​ 对于那些对流量突增不敏感的简单应用。

​ 局限性：在时间窗口切换的瞬间，可能会允许两倍于阈值的请求通过，导致服务瞬时压力加大。

滑动窗口算法

特点：在计数器算法的基础上改进，将时间窗口划分为多个小窗口，以达到更平滑控制流量的效果。

​ 适用场景：

​ 适合需要更平滑控制请求流量的场景。

​ 当需要减少由于时间窗口切换带来的流量波动时非常有用。

令牌桶算法

特点：通过固定速率添加令牌到桶中，请求需要消耗令牌才能被处理，支持一定程度的突发流量。

​ 适用场景：

​ 适合对突发流量有一定容忍度的场景。

​ 当需要对复杂的分布式系统进行限流，且要求系统能够应对短时间内的高流量压力时。

漏桶算法

特点：以恒定的速率处理请求，可以很好地控制数据的平均速率和突发速率，但超出容量的请求会被丢弃或等待。

​ 适用场景：

​ 适合需要严格控制请求处理速率，保证服务稳定性的场景。

​ 当系统处理能力有硬性限制，不能容忍超过一定速率的请求时。

综合比较

​ 对于简单应用或单实例服务，计数器算法因其实现简单而受到青睐。

​ 滑动窗口算法提供了比计数器更平滑的限流控制，适合对流量波动敏感的应用。

​ 令牌桶算法因其支持一定程度的突发流量而广泛应用于需要灵活处理高低流量变化的分布式系统中。

​ 漏桶算法适合对处理速率有严格要求，需要稳定处理请求的系统。

示例实现

'''计数器算法实现'''
import time

class RateLimiter:
    def __init__(self, max_requests, window_size):
        """
        初始化计数器限流器
        :param max_requests: 时间窗口内的最大请求数
        :param window_size: 时间窗口大小，单位为秒
        """
        self.max_requests = max_requests
        self.window_size = window_size
        self.request_counts = 0
        self.start_time = time.time()

    def allow_request(self):
        """
        判断是否允许当前请求
        :return: 如果允许请求，返回True；否则返回False
        """
        current_time = time.time()
        # 如果当前时间超出了时间窗口，则重置计数器和开始时间
        if current_time - self.start_time > self.window_size:
            self.request_counts = 0
            self.start_time = current_time

        # 如果当前请求次数小于最大请求数，则允许请求并增加计数
        if self.request_counts < self.max_requests:
            self.request_counts += 1
            return True
        else:
            # 否则，拒绝请求
            return False

# 示例使用
if __name__ == "__main__":
    limiter = RateLimiter(5, 60)  # 每60秒允许最多5个请求

    # 模拟请求
    for i in range(10):
        time.sleep(1)  # 每秒发送一个请求
        if limiter.allow_request():
            print(f"请求{i + 1}: 允许")
        else:
            print(f"请求{i + 1}: 被限流")

'''滑动窗口算法实现'''
import time
from collections import deque

class SlidingWindowLimiter:
    def __init__(self, max_requests, window_size):
        """
        初始化滑动窗口限流器
        :param max_requests: 时间窗口内允许的最大请求量
        :param window_size: 时间窗口大小，单位为秒
        """
        self.max_requests = max_requests
        self.window_size = window_size
        self.requests = deque()

    def allow_request(self):
        """
        判断是否允许当前请求通过
        :return: 如果允许请求通过，返回True；如果不允许，返回False
        """
        current_time = time.time()
        # 移除时间窗口之前的请求记录
        while self.requests and self.requests[0] < current_time - self.window_size:
            self.requests.popleft()
        
        if len(self.requests) < self.max_requests:
            # 如果当前时间窗口内的请求量小于最大允许请求量，则允许当前请求通过
            self.requests.append(current_time)
            return True
        else:
            # 否则，拒绝当前请求
            return False

# 示例使用
if __name__ == "__main__":
    # 创建一个滑动窗口限流器，最大请求量为3，时间窗口为10秒
    limiter = SlidingWindowLimiter(3, 10)

    # 模拟请求
    for _ in range(5):
        if limiter.allow_request():
            print("请求通过")
        else:
            print("请求被限流")
        time.sleep(1)

'''令牌桶算法实现'''

import time
from threading import Lock

class TokenBucket:
    def __init__(self, rate, capacity):
        self._rate = rate  # 每秒往桶里放入令牌的速率
        self._capacity = capacity  # 桶的容量
        self._tokens = capacity  # 当前桶内的令牌数量
        self._last_time = time.time()  # 上次放入令牌的时间
        self._lock = Lock()  # 线程锁

    def consume(self, tokens=1):
        with self._lock:
            # 计算自上次放入令牌以来应该放入的令牌数量
            now = time.time()
            tokens_to_add = (now - self._last_time) * self._rate
            self._tokens = min(self._capacity, self._tokens + tokens_to_add)
            self._last_time = now

            # 检查桶内是否有足够的令牌
            if tokens <= self._tokens:
                self._tokens -= tokens
                return True
            return False

# 使用示例
bucket = TokenBucket(5, 10)  # 每秒放入5个令牌，桶容量为10
print(bucket.consume(3))  # 请求3个令牌
print(bucket.consume(7))  # 请求7个令牌
time.sleep(1)
print(bucket.consume(6))  # 经过1秒后，再请求6个令牌

'''漏桶算法实现'''
import time
import threading

class LeakyBucket:
    def __init__(self, capacity, leak_rate):
        """
        初始化漏桶算法
        :param capacity: 桶的容量
        :param leak_rate: 桶的漏水速率（每秒）
        """
        self.capacity = capacity  # 桶的最大容量
        self.leak_rate = leak_rate  # 每秒漏水量
        self.water = 0  # 当前桶内水量（即当前累积的请求量）
        self.last_leak_time = time.time()  # 上一次漏水时间

    def allow_request(self, request_units=1):
        """
        判断请求是否可以通过
        :param request_units: 请求量（默认为1）
        :return: 如果允许请求通过，返回True；否则返回False
        """
        current_time = time.time()
        # 计算上次漏水后桶内剩余的水量
        self.water -= (current_time - self.last_leak_time) * self.leak_rate
        self.water = max(0, self.water)  # 水量不能为负
        self.last_leak_time = current_time
        
        if self.water + request_units <= self.capacity:
            # 如果加上当前请求后不会溢出，则允许请求通过
            self.water += request_units
            return True
        else:
            # 否则，拒绝请求
            return False

# 示例使用
if __name__ == "__main__":
    bucket = LeakyBucket(5, 1)  # 容量为5，每秒漏水速率为1

    def send_requests():
        for _ in range(10):
            print(f"请求发送时间: {time.strftime('%X')} - 请求{'通过' if bucket.allow_request() else '被限流'}")
            time.sleep(0.5)

    thread = threading.Thread(target=send_requests)
    thread.start()
    thread.join()

  for _ in range(10):
        print(f"请求发送时间: {time.strftime('%X')} - 请求{'通过' if bucket.allow_request() else '被限流'}")
        time.sleep(0.5)

thread = threading.Thread(target=send_requests)
thread.start()
thread.join()