接口限流算法(代码片段)

import time
class CounterLimter:
    def __init__(self,interval,limit):
        #初始时间
        self.startTime=time.time()
        #时间窗口
        self.interval = interval
        #限制请求数
        self. limit =limit
        #请求计数
        self.requestCount = 0
    def acquire(self):
        now = time.time()
        if(now < self.startTime +self.interval):
            if(self.requestCount<self.limit):
                self.requestCount +=1
                return True
            else:
                print("在时间窗口内达到最大请求数")
                print(self.requestCount)
                return False
        else:
            print("超时重置")
            self.startTime = time.time()
            self.requestCount = 0
            return True

Count = CounterLimter(60,100)
for i  in range(0,200):
    time.sleep(0.2)
    Count.acquire()

import time
class LeakyBucketRateLimiter(object):
    def __init__(self, capacity, leak_rate,sec):
        """
        初始化漏桶
        :param capacity: 桶容量
        :param leak_rate: 恒定的消费速度（Reqs/秒）
        :param _water_level:桶当前请求数量
        """
        self._capacity = float(capacity)
        self._leak_rate = float(leak_rate)
        self._water_level = 0.0
        self.sec = sec
        # 上次漏水的时间
        self._last_time = time.time()

    def acquire(self, level=1):
        # 现在时间戳
        now = time.time()
        #每超过时间间隔self.sec秒，处理一次
        if (now - self._last_time >= self.sec):
            delta = int(self._leak_rate * (now - self._last_time))
            #如果桶中的请求数小于应该处理的请求数
            if (self._water_level <= delta):
                delta = self._water_level - 0
                self._water_level = 0
            else:
                self._water_level = self._water_level - delta
            #执行请求：从队列中取出delta个请求
            print("请求流出数量:",delta)
            self._last_time = now
        # 尝试加水，并看水桶是否满了
        if level + self._water_level > self._capacity:
            print("请求溢出")
        else:
            #添加请求到队列中
            self._water_level += level
        print("现在桶中的请求数:",self._water_level)

#桶的大小为10，速率为3Reqs/秒
LeakyBucket = LeakyBucketRateLimiter(10,3,1)
#
for i in range(0,200):
    time.sleep(0.2)
    LeakyBucket.acquire()

import time
class TokenBucketRateLimiter(object):
    def __init__(self, capacity=1, fill_rate=1):
        """
        初始化令牌桶限流器
        :param capacity: 令牌桶容量
        :param fill_rate: 放入令牌的速度（Reqs/秒）
        """
        self._capacity = float(capacity)
        self._rate = float(fill_rate)
        self._bucket_tokens = float(capacity)
        # 上次添加令牌的时间
        self._last_time = int(time.time())

    def acquire(self, tokens=1):
        # 先执行添加令牌的操作
        if self._bucket_tokens < self._capacity:
            now = time.time()
            if(now - self._last_time >1):
                delta = int((now - self._last_time) * self._rate)
                self._last_time = now
                self._bucket_tokens = min(self._capacity, self._bucket_tokens + delta)

        if tokens > self._bucket_tokens:
            # 无法获取令牌了，数量不够
            return False
        self._bucket_tokens -= tokens
        return True