Redis + Lua implementation of distributed interface current limiting

Preface

redis + lua Script has become the mainstream current limiting scheme for individual projects .

redis With its characteristics, it has become the leader of middleware , The latest official test data ：

• The speed of reading is zero 110000 Time /s
• The speed of writing is 81000 Time /s.

lua：

• Reduce network overhead ： Use Lua Script , No need to Redis Send multiple requests , Only once , Reduce network transmission
• Atomic manipulation ：Redis Will the whole Lua The script executes as a command , atom , Don't worry about concurrency
• Reuse ：Lua Once the script is executed , It will be kept forever Redis in ,, Other clients can be reused

operation

Add the following comments at the interface where current restriction is required （@RedisLimit）, On the basis of the original , Current limiting can be achieved without adding any dependencies .

@RedisLimit(name = " Order spike ", prefix = "seckill", key = "distributed", count = 1, period = 1, limitType = LimitType.IP, msg = " There are many people waiting in line at present , Please try again later ！")
@GetMapping("/limit/distributed/{id}")
public ResponseEntity<Object> limitDistributed(@PathVariable("id") String id) {
    

    return ResponseEntity.ok(" Successfully purchased ：" + id + " individual ");
}

Introduce

/** *  Resource name  */
String name() default "";

/** *  Prefix  */
String prefix() default "";

/** *  resources key */
String key() default "";

/** *  Maximum visits  */
int count();

/** *  Time , Second level  */
int period();

/** *  type  */
LimitType limitType() default LimitType.CUSTOMER;

/** *  Prompt information  */
String msg() default " The system is busy , Please try again later ";

function

• The default is based on the global interface QPS As a flow control indicator
• Independent IP Switch freely with the global interface
• You can customize the time and within the specified time QPS
• According to the key Value for later data monitoring and statistics

principle

• Take the flow as the cut-off point 、 Sliding time window as the core algorithm .

• lua Script to ensure its atomic operation

Core code （ Part of the show ）

lua Script

redis.replicate_commands();
local listLen,time
listLen = redis.call('LLEN', KEYS[1]) 
if listLen and tonumber(listLen) < tonumber(ARGV[1]) then
local a = redis.call('TIME');
redis.call('LPUSH', KEYS[1], a[1]*1000000+a[2]) 
else
time = redis.call('LINDEX', KEYS[1], -1)
local a = redis.call('TIME');
if a[1]*1000000+a[2] - time < tonumber(ARGV[2])*1000000 then
return 0;
else
redis.call('LPUSH', KEYS[1], a[1]*1000000+a[2])
redis.call('LTRIM', KEYS[1], 0, tonumber(ARGV[1])-1)
end
end
return 1;

Tangent point processing

Long number = redisTemplate.execute(SECKILL_SCRIPT, keys, count, period);
if(number != null && number.intValue() == 1){
    
                return pjp.proceed();
            }