设计出对外部http调用的速率限制器，且不丢弃请求。

我们可以使用令牌桶算法来实现速率限制器。在每个固定的时间里，该算法会发放一定数量的令牌，即令牌桶。每当有一个请求过来时，需要消耗一个令牌，只有当有足够的令牌时才能执行该请求。如果在请求到达时没有令牌可用，该请求就需要被阻塞。这样就可以实现对请求速率的控制，避免服务器的过载。

具体地，我们可以通过以下代码示例实现令牌桶算法：

import time
import threading

class RateLimiter:
    def __init__(self, rate, capacity):
        self._rate = rate # 每秒钟产生的令牌个数
        self._capacity = capacity # 令牌桶的容量
        self._tokens = capacity # 当前令牌桶中的令牌数
        self._lock = threading.Lock() # 锁对象
        self._last_timestamp = time.time() # 上一次发放令牌的时间戳
    
    def acquire(self, tokens=1, timeout=None):
        """从令牌桶中获取指定数量的令牌"""
        # 等待直到能够获取到足够的令牌
        end_time = None if timeout is None else time.time() + timeout
        while True:
            with self._lock:
                # 计算时间间隔，产生新的令牌
                now = time.time()
                time_passed = now - self._last_timestamp
                new_tokens = int(time_passed * self._rate)
                self._tokens = min(self._capacity, self._tokens + new_tokens)
                self._last_timestamp = now
                
                # 判断是否有足够的令牌
                if self._tokens >= tokens:
                    self._tokens -= tokens
                    return True
                
            # 等待一段时间再尝试获取令牌
            time.sleep(0.1)
            if end_time is not None and time.time() >= end_time:
                return False

使用示例：

rate_limiter = RateLimiter(rate=1, capacity=10)

# 模拟 13 次请求
for i in range(13):
    if rate_limiter.acquire(timeout=0.1):
        print(f"发送第 {i+1} 次请求")
    else:
        print(f"第 {i+1} 次请求被阻塞")

输出结果：

发送第 1 次请求
发送第 2 次请求
发送第 3 次请求
发送第 4 次请求
发送第 5 次请求
发送第 6 次请求
第 7 次请求被阻塞
第 8 次请求被阻塞
第 9 次请求被阻塞
第 10 次请求被阻塞
第 11 次请求被阻塞
第 12 次请求被阻塞
第