一. 业务背景

 第三方服务接口存在频率调用限制（例如，1s5次，超过5次返回超出频率），己方服务存在并发处理的情况，为了保证服务的成功率，且达到第三方限制的最大吞吐量，故需要一个限频调用的算法

二.实现思路

常见限频算法一般有五种，漏桶算法、令牌桶算法、固定窗口算法，滑动窗口算法，漏斗算法，五种算各有优劣，详情见下表

 三.需求分析

 因为第三方的限频模式可能有多种多样，所以此处采用了滑动窗口算法的精确限频

四.代码实现

 这里调整了滑动窗口算法的逻辑，返回了需要等待的时间，保证了请求的成功率，缺点就是消耗资源增加，并且请求可能会延迟很久

 private async Task Sleep(RequestInfo requestInfo)
        {
            if (requestInfo is null || requestInfo.Key.IsNullOrEmpty())
            {
                return;
            }

            TimeSpan? remainingWaitTime;

            do
            {
                remainingWaitTime = await GetRemainingWaitTimeAsync(requestInfo);

                if (remainingWaitTime.HasValue)
                {
                    _logger.LogInformation("延迟时间：" + remainingWaitTime.Value.TotalMilliseconds);
                    await Task.Delay(remainingWaitTime.Value);
                }
                await Task.Delay(TimeSpan.FromMilliseconds(10)); // 做个时间切片，减少循环次数
            } while (remainingWaitTime.HasValue);
        }

        private static async Task<TimeSpan?> GetRemainingWaitTimeAsync(RequestInfo requestInfo)
        {
            var rules = requestInfo.RateLimitRules;
            long timeStamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

            // 创建一个管道
            var pipe = RedisHelper.StartPipe();

            foreach (var rule in rules)
            {
                var key = "rate_limit:" + requestInfo.Key + ":" + rule.Period.TotalMilliseconds;
                pipe.ZAdd(key, (timeStamp, timeStamp))
                .ZRemRangeByScore(key, 0, timeStamp - (long)rule.Period.TotalMilliseconds)
                .ZCard(key)
                .Expire(key, rule.Period); // 为键设置过期时间
            }
            // 执行管道中的所有命令并获取结果
            var result = pipe.EndPipe();

            // 检查每个限流规则是否超出限制，并计算最长的剩余等待时间
            TimeSpan? longestRemainingWaitTime = null;
            for (int i = 0; i < rules.Count; i++)
            {
                // 上面每次循环执行四条命令  所以次数×4
                int currentCount = Convert.ToInt32(result[4 * i + 2]);
                if (currentCount >= rules[i].Limit)
                {
                    var key = "rate_limit:" + requestInfo.Key + ":" + rules[i].Period.TotalMilliseconds;
                    var scores = await RedisHelper.ZRangeByScoreWithScoresAsync<long>(key, 0, 0);
                    var minScore = scores.Length > 0 ? (long)scores[0].score : timeStamp;
                    var remainingMilliseconds = timeStamp - minScore;
                    var currentRemainingWaitTime = TimeSpan.FromMilliseconds(remainingMilliseconds);
                    if (longestRemainingWaitTime == null || currentRemainingWaitTime > longestRemainingWaitTime)
                    {
                        longestRemainingWaitTime = currentRemainingWaitTime;
                    }
                }
            }

            return longestRemainingWaitTime;
        }

五.参考文档

https://www.cnblogs.com/duanxz/p/4123068.html

https://www.cnblogs.com/Kingfans/p/16263774.html