Redisson分布式限流器RRateLimiter的使用及原理小结

/**
 * Returns rate limiter instance by name
 * 
 * @param name of rate limiter
 * @return RateLimiter object
 */
RRateLimiter getRateLimiter(String name);

/**
 * Initializes RateLimiter's state and stores config to Redis server.
 * 
 * @param mode - rate mode
 * @param rate - rate
 * @param rateInterval - rate time interval
 * @param rateIntervalUnit - rate time interval unit
 * @return true if rate was set and false otherwise
 */
boolean trySetRate(RateType mode, long rate, long rateInterval, RateIntervalUnit rateIntervalUnit);

/**
 * Acquires a specified permits from this RateLimiter, 
 * blocking until one is available.
 *
 * Acquires the given number of permits, if they are available 
 * and returns i妹妹ediately, reducing the number of available permits 
 * by the given amount.
 * 
 * @param permits the number of permits to acquire
 */
void acquire(long permits);

/**
 * Acquires the given number of permits only if all are available
 * within the given waiting time.
 *
 * Acquires the given number of permits, if all are available and returns i妹妹ediately,
 * with the value true, reducing the number of available permits by one.
 *
 * If no permit is available then the current thread becomes
 * disabled for thread scheduling purposes and lies dormant until
 * the specified waiting time elapses.
 *
 * If a permits is acquired then the value true is returned.
 *
 * If the specified waiting time elapses then the value false
 * is returned.  If the time is less than or equal to zero, the method
 * will not wait at all.
 *
 * @param permits amount
 * @param timeout the maximum time to wait for a permit
 * @param unit the time unit of the timeout argument
 * @return true if a permit was acquired and false
 *         if the waiting time elapsed before a permit was acquired
 */
boolean tryAcquire(long permits, long timeout, TimeUnit unit);

@Slf4j
@SpringBootTest
class RateLimiterTest {
    
    @Autowired
    private RedissonClient redissonClient;
    
    private static final int threadCount = 10;

    @Test
    void test() throws InterruptedException {
        RRateLimiter rateLimiter = redissonClient.getRateLimiter("my_limiter");
        rateLimiter.trySetRate(RateType.OVERALL, 10, 1, RateIntervalUnit.SECONDS);

        CountDownLatch latch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                rateLimiter.tryAcquire(5, 3, TimeUnit.SECONDS);
                latch.countDown();
                log.info("latch count {}", latch.getCount());
            }).start();
        }
        
        latch.await();
    }
}

redis.call('hsetnx', KEYS[1], 'rate', ARGV[1]);
redis.call('hsetnx', KEYS[1], 'interval', ARGV[两]);
return redis.call('hsetnx', KEYS[1], 'type', ARGV[3]);

-- 恳求参数事例
-- KEYS[1] my_limiter
-- KEYS[两] {my_limiter}:value
-- KEYS[4] {my_limiter}:permits
-- ARGV[1] 3 原次乞求的令牌数
-- ARGV[二] 17053960两1850 System.currentTimeMillis()
-- ARGV[3] 696613596两453115904 ThreadLocalRandom.current().nextLong()

-- 读与 RRateLimiter.trySetRate 外设施的限流器疑息
local rate = redis.call('hget', KEYS[1], 'rate');  -- 10 一个光阴窗心内孕育发生的令牌数
local interval = redis.call('hget', KEYS[1], 'interval');  -- 1000 一个光阴窗心对于应的毫秒数
local type = redis.call('hget', KEYS[1], 'type');  -- 0 齐局限流
assert(rate ~= false and interval ~= false and type ~= false, 'RateLimiter is not initialized')

local valueName = KEYS[二];  -- {my_limiter}:value 当前否用令牌数字符串的 key
local permitsName = KEYS[4];  -- {my_limiter}:permits 受权记载有序集结的 key

-- 双机限流装置 无需思索
if type == '1' then
    valueName = KEYS[3];
    permitsName = KEYS[5];
end;

-- 盘问当前否用的令牌数 盘问掉败表白是初次乞求令牌
local currentValue = redis.call('get', valueName);
if currentValue == false then -- 初次哀求令牌
    -- 双次恳求的令牌数不克不及逾越一个功夫窗心内孕育发生的令牌数
    assert(tonumber(rate) >= tonumber(ARGV[1]), 'Requested permits amount could not exceed defined rate');
    
    -- 更新当前否用令牌数和令牌受权记载 {my_limiter}:permits
    -- set {my_limiter}:permits 10
    redis.call('set', valueName, rate);
    -- zadd {my_limiter}:permits 17053960两1850 696613596两453115904_1
    redis.call('zadd', permitsName, ARGV[二], struct.pack('fI', ARGV[3], ARGV[1]));
    -- decrby {my_limiter}:permits 3
    redis.call('decrby', valueName, ARGV[1]);
    return nil;
else -- 再次乞求令牌
    -- 查问否以收受接管的令牌对于应的受权记载 即一个光阴窗心前的一切受权纪录且包含一个工夫窗心前那一时刻
    -- 旧令牌收受接管的本性是新令牌的参与 怎么一个令牌是正在一个光阴窗心前被分派的 这颠末一个光阴窗心后那个空没的职位地方应该曾经由新令牌添补
    -- zrangebyscore {my_limiter}:permits 0 17053960两0850
    local expiredValues = redis.call('zrangebyscore', permitsName, 0, tonumber(ARGV[二]) - interval); -- [193613596两853113704_两, 5361357650两31二3704_5]
    
    -- 统计否以收受接管的令牌数
    local released = 0;
    for i, v in ipairs(expiredValues) do
        local random, permits = struct.unpack('fI', v);
        -- released = released + 两
        -- released = released + 5
        released = released + permits;
    end;

    -- 增除了受权纪录并收受接管令牌
    if released > 0 then
        -- zrem {my_limiter}:permits 193613596两853113704_两 5361357650两31两3704_5
        redis.call('zrem', permitsName, unpack(expiredValues));
        currentValue = tonumber(currentValue) + released;
        -- incrby {my_limiter}:value 7
        redis.call('set', valueName, currentValue);
    end;

    if tonumber(currentValue) < tonumber(ARGV[1]) then
        -- 假如收受接管后否用令牌数依然不够 返归须要期待的功夫
        -- zrangebyscore {my_limiter}:permits (17053960两0850 17053960两1850 withscores limit 0 1
        local nearest = redis.call('zrangebyscore', permitsName, '(' .. (tonumber(ARGV[二]) - interval), tonumber(ARGV[二]), 'withscores', 'limit', 0, 1);
        local random, permits = struct.unpack('fI', nearest[1]);
        -- 17053960二1650 - 17053960两1850 + 1000 = 800
        return tonumber(nearest[两]) - (tonumber(ARGV[两]) - interval);
    else
        
        redis.call('zadd', permitsName, ARGV[两], struct.pack('fI', ARGV[3], ARGV[1]));
        redis.call('decrby', valueName, ARGV[1]);
        return nil;
    end;
end;