FUNCTION LIMIT_API_CALL(ip)
ts = CURRENT_UNIX_TIME()
keyname = ip+":"+ts
current = GET(keyname)
IF current != NULL AND current > 10 THEN
	ERROR "too many requests per second"
ELSE
	MULTI
		INCR(keyname,1)
		EXPIRE(keyname,10)
	EXEC
	PERFORM_API_CALL()
END

multi命令用于标识一个命令集被包含在一个事务块中，exec保证该事务块命令集执行的原子性。 ## 1.2. 模式2

FUNCTION LIMIT_API_CALL(ip):
current = GET(ip)
IF current != NULL AND current > 10 THEN
	ERROR "too many requests per second"
ELSE
	value = INCR(ip)
	IF value == 1 THEN
		EXPIRE(value,1)
	END
	PERFORM_API_CALL()
END

local current
current = redis.call("incr",KEYS[1])
if tonumber(current) == 1 then
	redis.call("expire",KEYS[1],1)
end

FUNCTION LIMIT_API_CALL(ip)
current = LLEN(ip)
IF current > 10 THEN
	ERROR "too many requests per second"
ELSE
	IF EXISTS(ip) == FALSE
		MULTI
			RPUSH(ip,ip)
			EXPIRE(ip,1)
		EXEC
	ELSE
		RPUSHX(ip,ip)
	END
	PERFORM_API_CALL()
END

这里产生race condition不会有大问题的原因在于，else分支使用的rpushx，它不会导致if not than init的问题，并且expire命令将在创建list的时候以原子的形式捆绑执行。不会产生key泄漏，导致永不失效的情况产生。

	local key = "rate.limit:" .. KEYS[1] --限流KEY
	local limit = tonumber(ARGV[1]) --限流大小
	local expire_time = ARGV[2] --过期时间
	local current = tonumber(redis.call('get', key) or "0")
	if current + 1 > limit then --超出限流大小
	  return 0
	else --请求数+1，并设置expire_time秒之后过期
	  redis.call("INCRBY", key, "1")
	  redis.call("EXPIRE", key, expire_time)
	  return 1
	end

System.out.println(new LimitTest().accessLimit("192.168.1.100", 2, 3, jedis));
System.out.println(new LimitTest().accessLimit("192.168.1.100", 2, 3, jedis));
System.out.println(new LimitTest().accessLimit("192.168.1.100", 2, 3, jedis));
TimeUnit.SECONDS.sleep(3);
System.out.println(new LimitTest().accessLimit("192.168.1.100", 2, 3, jedis));
System.out.println(new LimitTest().accessLimit("192.168.1.100", 2, 3, jedis));
TimeUnit.SECONDS.sleep(2);
System.out.println(new LimitTest().accessLimit("192.168.1.100", 2, 3, jedis));

true
true
false
true
true
false

local key = "rate.limit." .. ARGV[1] --限流KEY
local limit = tonumber(ARGV[2]) --限流窗口允许的最大请求数
local interval = ARGV[3] --限流间隔,秒
local now = ARGV[4] --当前Unix时间戳
--计算key
local subject = math.floor(now / interval)
key = key .. '.' .. subject .. '.' .. limit .. '.' .. interval

local current = tonumber(redis.call("incr", key))
if current == 1 then
	redis.call("expire", key, interval)
end

local ttl = redis.call("ttl", key)
local remaining = math.max(limit - current, 0);
--返回值为：是否通过0或1，最大请求数，剩余令牌,限流窗口重置时间
return {limit - current >= 0,  remaining, limit, ttl}

local rate_limits = cjson.decode(ARGV[1])
local now = tonumber(ARGV[2])

local prefix_key = "rate.limit." --限流KEY
local result = {}
local passed = true;
--计算请求是否满足每个限流规则
for i, rate_limit in ipairs(rate_limits) do
	local limit = rate_limit[2]
	local interval = rate_limit[3]
	local subject = math.floor(now / interval)
	local limit_key =  prefix_key .. rate_limit[1] .. '.' .. subject .. '.' .. limit .. '.' .. interval
	local requested_num = tonumber(redis.call('GET', limit_key)) or 0 --请求数，默认为0
	if requested_num >= limit then
		passed = false
		--依次为　限流key,限流大小,限流间隔,剩余请求数,是否通过
		table.insert(result, { limit_key, limit, interval,  math.max(limit - requested_num, 0), 0})
	else
		table.insert(result, { limit_key, limit, interval,  math.max(limit - requested_num, 0), 1 })
	end
end

local summary = { }
for key,value in ipairs(result) do
	local limit_key = value[1]
	local limit = value[2]
	local interval = value[3]
	if passed then
		--如果通过, 将所有的限流请求数加1
		local current = tonumber(redis.call("incr", limit_key))
		if current == 1 then
			redis.call("expire", limit_key, interval)
		end
		--添加两个值　是否通过0或1　剩余请求数
		table.insert(summary, 1)
		table.insert(summary, math.max(limit - current, 0))
	else
		local pass = value[5]
		if not pass or pass == 0 then
			table.insert(summary, 0)
			table.insert(summary, 0)
		else
			table.insert(summary, 1)
			table.insert(summary, value[4])
		end
	end
	local ttl = redis.call("ttl", limit_key)
	--添加两个值　最大请求数　重置时间
	table.insert(summary, limit)
	table.insert(summary, ttl)
end

--返回值为: 是否通过0或1, 剩余令牌, 最大请求数, 限流窗口重置时间 ,...
return summary

	--两种规则，1秒钟1次请求，每分钟5次请求，为简单起见，规则未使用参数传入
	local current_timestamp = tonumber(ARGV[1]) -- 当前请求的时间
	local key = "rate.limit2:" .. KEYS[1] --限流KEY
	
	--删除列表中超过1分钟的请求
	redis.pcall('ZREMRANGEBYSCORE', key, 0, current_timestamp - 60)
	
	local passed1 = true
	local passed2 = true
	--获取第一个请求
	local last_drip = redis.pcall('ZREVRANGEBYSCORE', key, '+inf', '-inf', 'LIMIT', 0, 1)
	
	--比较上次的时间戳和当前请求的时间戳
	if last_drip[1] then
	    --上次请求的时间
	    local last_time = tonumber(last_drip[1])
	    passed1 = current_timestamp >=  (last_time + 1)
	end
	
	--获取前5个请求
	local last_drip = redis.pcall('ZREVRANGEBYSCORE', key, '+inf', '-inf', 'LIMIT', 0, 5)
	
	--比较上次的时间戳和当前请求的时间戳
	if last_drip[5] then
	    --第5次请求的时间
	    local last_time = tonumber(last_drip[5])
	    passed2  = current_timestamp >=  (last_time + 60)
	end
	
	if passed1 and passed2 then
	  redis.pcall('ZADD', key, current_timestamp, current_timestamp)
	end
	--设置1分钟过期
	redis.call('EXPIRE', key, 60)
	return {current_timestamp,last_drip, passed1, passed2}

System.out.println(new LimitTest3().accessLimit("192.168.1.100", jedis));
System.out.println(new LimitTest3().accessLimit("192.168.1.100", jedis));
TimeUnit.SECONDS.sleep(1);
System.out.println(new LimitTest3().accessLimit("192.168.1.100", jedis));
TimeUnit.SECONDS.sleep(1);
System.out.println(new LimitTest3().accessLimit("192.168.1.100", jedis));
TimeUnit.SECONDS.sleep(1);
System.out.println(new LimitTest3().accessLimit("192.168.1.100", jedis));
TimeUnit.SECONDS.sleep(1);
System.out.println(new LimitTest3().accessLimit("192.168.1.100", jedis));
TimeUnit.SECONDS.sleep(1);
System.out.println(new LimitTest3().accessLimit("192.168.1.100", jedis));
TimeUnit.SECONDS.sleep(61);
System.out.println(new LimitTest3().accessLimit("192.168.1.100", jedis));

	[1484551710, [], 1, 1]
	[1484551710, [1484551710], null, 1]
	[1484551711, [1484551710], 1, 1]
	[1484551712, [1484551711, 1484551710], 1, 1]
	[1484551713, [1484551712, 1484551711, 1484551710], 1, 1]
	[1484551714, [1484551713, 1484551712, 1484551711, 1484551710], 1, 1]
	[1484551715, [1484551714, 1484551713, 1484551712, 1484551711, 1484551710], 1, null]
	[1484551776, [], 1, 1]

local subject = "rate.limit." .. ARGV[1] --限流KEY
local limit = tonumber(ARGV[2]) --限流窗口允许的最大请求数
local interval = tonumber(ARGV[3]) --限流间隔,秒
local precision = tonumber(ARGV[4])
local now = tonumber(ARGV[5]) --当前Unix时间戳
--桶的大小不能超过限流的间隔
precision = math.min(precision, interval)

--重新计算限流的KEY，避免传入相同的key，不同的间隔导致冲突
subject = subject .. '.' .. limit .. '.' .. interval .. '.' .. precision

--桶的数量，与位置
local bucket_num = math.ceil(interval / precision)
local oldest_req_key = subject .. ':o'
local bucket_key = math.floor(now / precision)
local trim_before = bucket_key - bucket_num + 1 --需要删除的key
local oldest_req = tonumber(redis.call('GET', oldest_req_key)) or trim_before --最早请求时间，默认为0
trim_before = math.min(oldest_req, trim_before)
--判断当前桶是否存在
local current_bucket = redis.call("hexists", subject, bucket_key)
if current_bucket == 0 then
	redis.call("hset", subject, bucket_key, 0)
end


	
	--请求总数
	local max_req = 0;
	local subject_hash = redis.call("hgetall", subject) or {}
	local last_req = now; --最近的访问时间，计算重置窗口
	for i = 1, #subject_hash, 2 do
	    local ts_key = tonumber(subject_hash[i])
	    if ts_key < trim_before and #subject_hash > 2  then
	        redis.call("hdel", subject, ts_key)
	--        table.insert(dele, ts_key)
	    else
	        local req_num =tonumber(subject_hash[i + 1])
	        max_req = max_req +  req_num
	        if req_num ~= 0 then
	            last_req = math.min(last_req, math.floor(ts_key * precision))
	        end
	    end
	end
	local reset_time =interval - now+  last_req;
	
	if max_req >= limit then
	    --返回值为：是否通过0或1，最大请求数，剩余令牌,限流窗口重置时间
	    return {0, 0, limit, reset_time}
	end
	
-- 当前请求+1
local current = tonumber(redis.call("hincrby", subject, bucket_key, 1))
-- interval+precision之后过期
redis.call("expire", subject, interval+precision)
redis.call("setex", oldest_req_key,interval+precision , now )

--返回值为：是否通过0或1，最大请求数，剩余令牌,限流窗口重置时间
return {1,  limit - max_req - 1, limit, reset_time}

	local rate_limits = cjson.decode(ARGV[1])
	local now = tonumber(ARGV[2])
	
	local prefix_key = "rate.limit." --限流KEY
	local result = {}
	local passed = true;
	--计算请求是否满足每个限流规则
	for i, rate_limit in ipairs(rate_limits) do
	    local limit = rate_limit[2]
	    local interval = rate_limit[3]
	    local precision = rate_limit[4]
	    --桶的大小不能超过限流的间隔
	    precision = math.min(precision, interval)
	
	    --重新计算限流的KEY，避免传入相同的key，不同的间隔导致冲突
	    local subject = prefix_key .. rate_limit[1] .. '.' .. limit .. '.' .. interval .. '.' .. precision
	
	    --桶的数量，与位置
	    local bucket_num = math.ceil(interval / precision)
	    local oldest_req_key = subject .. '.o'
	    local bucket_key = math.floor(now / precision)
	    local trim_before = bucket_key - bucket_num + 1 --需要删除的key
	    local oldest_req = tonumber(redis.call('GET', oldest_req_key)) or trim_before --最早请求时间，默认为0
	    trim_before = math.min(oldest_req, trim_before)
	    --判断当前桶是否存在
	    local current_bucket = redis.call("hexists", subject, bucket_key)
	    if current_bucket == 0 then
	        redis.call("hset", subject, bucket_key, 0)
	    end
	
	    --请求总数
	    local max_req = 0;
	    local subject_hash = redis.call("hgetall", subject) or {}
	    local last_req = now; --最近的访问时间，计算重置窗口
	    for i = 1, #subject_hash, 2 do
	        local ts_key = tonumber(subject_hash[i])
	        if ts_key < trim_before and #subject_hash > 2  then
	            redis.call("hdel", subject, ts_key)
	            --        table.insert(dele, ts_key)
	        else
	            local req_num =tonumber(subject_hash[i + 1])
	            max_req = max_req +  req_num
	            if req_num ~= 0 then
	                last_req = math.min(last_req, math.floor(ts_key * precision))
	            end
	        end
	    end
	    local reset_time =interval - now+  last_req;
	    if max_req >= limit then
	        passed = false
	        --依次为　限流key,限流大小,限流间隔,对应的桶,最大请求数,是否成功,重置时间
	        table.insert(result, { subject, limit, interval, bucket_key, max_req, 0, reset_time, precision,oldest_req_key})
	    else
	        table.insert(result, { subject, limit, interval, bucket_key, max_req, 1, reset_time, precision,oldest_req_key})
	    end
	
	end
	
	-- 如果通过，增加每个限流规则
	if passed == true then
	    for key,value in ipairs(result) do
	        -- 当前请求+1
	        local subject = value[1]
	        local interval = value[3]
	        local bucket_key = value[4]
	        local precision = value[8]
	        local oldest_req_key = value[9]
	        local current = tonumber(redis.call("hincrby", subject, bucket_key, 1))
	        -- interval+precision之后过期
	        redis.call("expire", subject, interval+precision)
	        redis.call("setex", oldest_req_key,interval+precision , now )
	    end
	end
	
	-- 返回结果
	local summary = {}
	for key,value in ipairs(result) do
	    local pass = value[6]
	    if not pass or pass == 0 then
	        --添加四个值　是否通过0或1　剩余请求数 最大请求数　重置时间
	        table.insert(summary, 0)
	        table.insert(summary, 0)
	        table.insert(summary, value[2])
	        table.insert(summary, value[7])
	    else
	        table.insert(summary, 1)
	        if passed == true then
	            table.insert(summary, value[2] - value[5] - 1)
	        else
	            table.insert(summary, value[2] - value[5])
	        end
	
	        table.insert(summary, value[2])
	        table.insert(summary, value[7])
	    end
	end
	
	return summary

local subject = ARGV[1]
local key = "token.bucket." .. subject --桶的标识符
local burst = math.max(tonumber(ARGV[2]), 1) --桶中最大令牌数，最小值1，
local refillTime = tonumber(ARGV[3]) or 1000-- 向桶中添加令牌的周期，单位毫秒
local refillAmount = math.max(tonumber(ARGV[4]), 1) or 1 -- 每次refillTime向桶中添加的令牌数量，默认为1
local tokens_to_take       = tonumber(ARGV[5]) or 1 --当前请求需要的令牌数量
local now = tonumber(ARGV[6]) --当前时间，单位毫秒

local available_tokens = burst --可用的令牌数默认等于桶的容量
local last_update = now --第一次的last_update等于当前时间
local current = redis.call('HMGET', key, 'last_update', 'available_tokens')
if current.err ~= nil then
	redis.call('DEL', key)
	current = {}
	redis.log(redis.LOG_NOTICE, 'Cannot get ratelimit ' .. key)
	return redis.error_reply('Cannot get ratelimit ' .. key)
end


		
		--计算从上次的时间戳与当前时间戳计算应该添加的令牌数
		if current[1] then
		    --上次请求的时间
		    last_update = current[1]
		    local content = current[2]
		    --计算应该生成的令牌数
		    local delta_ms = math.max(now - last_update, 0)
		    local refillCount  = math.floor(delta_ms / refillTime) * refillAmount
		    --如果桶满，直接使用桶的容量
		    available_tokens = math.min(content + refillCount, burst)
		end
		
		-- 计算是否有足够的令牌给调用方
		local enough_tokens = available_tokens >= tokens_to_take
		--之后的请求要偿还之前发生的突发
		
-- 将令牌给调用方之后，桶中剩余的令牌数
if enough_tokens then
	available_tokens = math.min(available_tokens - tokens_to_take, burst)
	last_update = last_update + math.floor(tokens_to_take / refillAmount * refillTime)
else
	redis.log(redis.LOG_NOTICE, 'Cannot get enough tokens, tokens_to_take:' .. tokens_to_take .. ',available_tokens:' .. available_tokens)
	--计算恢复的时间
	local reset_time = last_update - now
	if reset_time < 0 then
		reset_time = now - last_update
	end
	return { 0, math.max(available_tokens, 0), burst, reset_time}
end
--重新设置令牌桶
redis.call('HMSET', key,
	'last_update', last_update,
	'available_tokens', available_tokens)

--如果没有新的请求过来，在桶满之后可以直接将该令牌删除。
redis.call('PEXPIRE', key, math.ceil((burst /  refillAmount) * refillTime))

return {1,  math.max(available_tokens, 0), burst,last_update - now }