Polly 速率限制过早[重复]

我正在尝试了解 Polly 的速率限制政策。

public class RateLimiter
{
    private readonly AsyncRateLimitPolicy _throttlingPolicy;
    private readonly Action<string> _rateLimitedAction;

    public RateLimiter(int numberOfExecutions, TimeSpan perTimeSpan, Action<string> rateLimitedAction)
    {       
        _throttlingPolicy = Policy.RateLimitAsync(numberOfExecutions, perTimeSpan);
        _rateLimitedAction = rateLimitedAction;
    }

    public async Task<T> Throttle<T>(Func<Task<T>> func)
    {
        var result = await _throttlingPolicy.ExecuteAndCaptureAsync(func);

        if (result.Outcome == OutcomeType.Failure)
        {
            var retryAfter = (result.FinalException as RateLimitRejectedException)?.RetryAfter ?? TimeSpan.FromSeconds(1);
            _rateLimitedAction($"Rate limited. Should retry in {retryAfter}.");
            return default;
        }

        return result.Result;
    }
}

在我的控制台应用程序中，我正在实例化一个RateLimiter每 10 秒最多 5 次调用。

var rateLimiter = new RateLimiter(5, TimeSpan.FromSeconds(10), err => Console.WriteLine(err));
var rdm = new Random();

while (true)
{
    var result = await rateLimiter.Throttle(() => Task.FromResult(rdm.Next(1, 10)));

    if (result != default) Console.WriteLine($"Result: {result}");

    await Task.Delay(200);
}

我预计会看到 5 个结果，而第 6 个结果的速率会受到限制。但这就是我得到的

Result: 9
Rate limited. Should retry in 00:00:01.7744615.
Rate limited. Should retry in 00:00:01.5119933.
Rate limited. Should retry in 00:00:01.2313921.
Rate limited. Should retry in 00:00:00.9797322.
Rate limited. Should retry in 00:00:00.7309150.
Rate limited. Should retry in 00:00:00.4812646.
Rate limited. Should retry in 00:00:00.2313643.
Result: 7
Rate limited. Should retry in 00:00:01.7982864.
Rate limited. Should retry in 00:00:01.5327321.
Rate limited. Should retry in 00:00:01.2517093.
Rate limited. Should retry in 00:00:00.9843077.
Rate limited. Should retry in 00:00:00.7203371.
Rate limited. Should retry in 00:00:00.4700262.
Rate limited. Should retry in 00:00:00.2205184.

我也尝试过使用ExecuteAsync代替ExecuteAndCaptureAsync并且它并没有改变结果。

public async Task<T> Throttle<T>(Func<Task<T>> func)
{
    try
    {
        var result = await _throttlingPolicy.ExecuteAsync(func);

        return result;
    }
    catch (RateLimitRejectedException ex)
    {
        _rateLimitedAction($"Rate limited. Should retry in {ex.RetryAfter}.");
        return default;
    }
}

这对我来说没有任何意义。我有什么遗漏的吗？

速率限制器的工作方式与您想象的有点不同。

假设我有 500 个请求，我想将其限制为每分钟 50 个。

预期：在前 50 次执行后，如果执行时间少于一分钟，则速率限制器将启动。

这种直观的方法没有考虑输入负载的平均分配。这可能会导致以下可观察到的行为：

• 假设前 50 次执行花费了 30 秒
• 然后你还要再等待30秒才能执行第51个请求

Polly 的速率限制器使用漏桶算法 https://en.wikipedia.org/wiki/Leaky_bucket罢工>

其工作原理如下：

• 桶有固定容量
• 桶底部有漏水
• 水滴以给定的频率离开水桶
• 水桶可以从顶部接收新的水滴
• 如果传入频率大于传出频率，则存储桶可能会溢出

所以，从技术上来说：

• 它是一个固定大小的队列
• 定期调用出队
• 如果队列已满，则入队会抛出异常

上述描述中最重要的信息如下：漏桶算法使用恒定速率清空桶。