/**
 * @Notes:滑动窗口算法
 * @Author:如果,
 * @Date: 2022/9/16,
 * @Time: 20:20,
 */
public function SlideTimeWindow()
{
    /**
     * 2.redis 滑动窗口实现方式
     * 限制1分钟内最大只能请求10次
     * 使用redis事务保证redis原子性
     */
    $redis = $this->redis;
    $limitTime = 60;
    $maxCount = 10;
    $redisKey = "slide_api";
    $nowTime = time();

    //使用管道提升性能 pipe
    $pipe = $redis->multi();

    //value 和 score 都使用时间戳,因为相同的元素会覆盖
    $pipe->zAdd($redisKey, $nowTime, $nowTime);

    //移除时间窗口之前的行为记录，剩下的都是时间窗口内的
    $pipe->zRemRangeByScore($redisKey, 0, $nowTime - $limitTime);
    //查看redis里还有多少次
    $pipe->zCard($redisKey);

    $pipe->expire($redisKey, 60 + 1);

    $replies = $pipe->exec();

    //有限时间窗口内的数量超过限制返回 true:false
    return $replies[2] <= $maxCount;
}

private $_water;    //漏斗的当前水量(也就是请求数)
private $_burst = 10;   //漏斗总量(超过将直接舍弃)
private $_rate = 1; //漏斗出水速率(限流速度)
private $_lastTime; //记录每次请求的时间(因为需要记录每次请求之间的出水量也就是请求数)
 
public function leakBucket()
{

    $nowTime = time();
    $redisKey = "leakBucket_api";

    if (!empty($time = $this->redis->get($redisKey))) {
        $this->_lastTime = $time; //获取上一次访问时间
    }

    if (!empty($water = $this->redis->get('water'))) {
        $this->_water = $water;//获取当前剩余量
    }

    $s = $nowTime - $this->_lastTime; //请求间隔

    $outCount = $s * $this->_rate;//请求间隔 * 出水速度 （着段时间应该出多少滴水）

    //桶里的水去 -  这段时间要出的水 = 桶里剩余的水
    $this->_water = ($this->_water - $outCount);
    //桶里剩余的水为 -数
    if ($this->_water <= 0) {
        $this->_water = 0; //漏斗重新赋值为空
    }

    if ($this->_water > $this->_burst) {
        echo "超出桶限制" . PHP_EOL;
        return false;
    }

    print_r($this->_water);
    //重新赋值时间  下次请求这个时间 就为上次时间
    $this->redis->set($redisKey, $nowTime);
    //把桶里剩余的水 重新赋值到redis里 并+1 本次也算请求
    $this->redis->set('water', $this->_water + 1);
}

<?php

class TokenLimit
{
   private $script = '
-- 生成token的速率 
local rate = tonumber(ARGV[1])
-- 令牌桶最大容量
local capacity = tonumber(ARGV[2])
-- 当前时间
local now = tonumber(ARGV[3])
-- 获取token的数量
local requested = tonumber(ARGV[4])
-- 填满整个桶需要多久时间
local fill_time = capacity / rate
-- 时间取整
local ttl = math.floor(fill_time*2)

-- 获取目前桶中剩余令牌的数量
-- 如果第一次进入，则设置桶内令牌的数量为最大值
local last_tokens = tonumber(redis.call("get", KEYS[1]))
if last_tokens == nil then
    last_tokens = capacity
end

-- 上次更新 桶的时间
local last_refreshed = tonumber(redis.call("get", KEYS[2]))
if last_refreshed == nil then
    last_refreshed = 0
end

-- 上次从桶中获取令牌的时间距离现在的时间 
local delta = math.max(0, now - last_refreshed)
-- 上次从桶中获取令牌的时间距离现在的时间内总共生成了令牌的数量
-- 如果超过了最大数量则丢弃多余的令牌
local filled_tokens = math.min(capacity, last_tokens + (rate * delta))
-- 本次请求令牌数量是否足够
local allowed = filled_tokens >= requested
-- 令牌桶剩余数量
local new_tokens = filled_tokens
if allowed then
    new_tokens = filled_tokens - requested
end

-- 更新桶中剩余令牌的数量
redis.call("setex", KEYS[1], ttl, new_tokens)
-- 更新获取令牌的时间
redis.call("setex", KEYS[2], ttl, now)
return allowed
';

    /**
     * @var string $key
     */
    private $key;

    /**
     * @var string $timestampKey
     */
    private $timestampKey;

    /**
     * @var int $rate
     */
    private $rate;

    /**
     * @var int $capacity
     */
    private $capacity;

    /**
     * @var Redis $redis
     */
    private $redis;

    /**
     * @var string $tokenFormat
     */
    private $tokenFormat = '%s.token';

    /**
     * @var string $timestampFormat
     */
    private $timestampFormat = '%s.ts';

    /**
     * TokenLimit constructor.
     * @param string $key
     * @param int $rate
     * @param int $burst
     * @param Redis $redis
     */
    public function __construct(string $key, int $rate, int $burst, Redis $redis)
    {
        $this->key = sprintf($this->tokenFormat, $key);
        $this->timestampKey = sprintf($this->timestampFormat, $key);
        $this->rate = $rate;
        $this->capacity = $burst;
        $this->redis = $redis;
    }

    /**
     * build argv
     * @param int $now_time
     * @param int $n
     * @return array
     */
    private function buildArgv(int $now_time, int $n): array
    {
        return array($this->key, $this->timestampKey, $this->rate, $this->capacity, $now_time, $n);
    }

    /**
     * execute script
     * @param int $now_time
     * @param int $n
     * @return bool
     */
    private function reserve(int $now_time, int $n): bool
    {
        return $this->redis->eval($this->script, $this->buildArgv($now_time, $n), 2); 
    }

    /**
     * reserve multi token
     * @param int $n
     * @return bool
     */
    public function allowN(int $n): bool
    {
        $now_time = time();
        return $this->reserve($now_time, $n);
    }

    /**
     * reserve one token
     * @return bool
     */
    public function allow(): bool
    {
        return $this->allowN(1);
    }
}

$redis = new Redis();
$redis->connect("192.168.4.61", 6379);

$tokenKey = 'token:test';
$tokenLimit = new TokenLimit($tokenKey, 1, 10, $redis);
$allowed = $tokenLimit->allow();
$allowed = $tokenLimit->allow();
$allowed = $tokenLimit->allow();
$allowed = $tokenLimit->allow();
$allowed = $tokenLimit->allow();
$allowed = $tokenLimit->allow();
var_dump($allowed);