nginx+lua乐观锁实现秒杀

package.path = '/class_goods/nginx/lua/5.1/lua-redis-cluster-master/?.lua;;/class_goods/nginx/lua/5.1/lua-resty-redis/lib/?.lua;;/class_goods/nginx/lua/5.1/lua-resty-limit-traffic-master/lib/?.lua;;'
ngx.header.content_type="text/plain";
--获取get或post参数--------------------

local request_method = ngx.var.request_method
local args = nil
local param = nil
--获取参数的值
--获取秒杀下单的用户id
if "GET" == request_method then
args = ngx.req.get_uri_args()
elseif "POST" == request_method then
ngx.req.read_body()
args = ngx.req.get_post_args()
end
user_id = args["user_id"]
--用户身份判断--省略
--用户能否下单--省略

--关闭redis的函数--------------------

local function close_redis(redis_instance)
-- if not redis_instance then
-- return
-- end
-- local ok,err = redis_instance:close();
-- if not ok then
ngx.say("close redis error : ",err);
-- end
end

--引入cjson类--------------------
--local cjson = require "cjson"

--连接redis--------------------
--[[
local function redis_cluster_init ()
local redis_cluster = require "resty.redis_cluster"
local cluster_id = "redis_cluster"
local startup_nodes = {
{"192.168.142.142", 6320},
{"192.168.142.142", 6321},
{"192.168.142.142", 6322},
{"192.168.142.142", 6323},
{"192.168.142.142", 6324},
{"192.168.142.142", 6325}
}
local opt = {
timeout = 1000,--执行超时时间
keepalive_size = 50,--长连接数量
keepalive_duration = 60000 --长连接保持时间
}
rc = redis_cluster:new(cluster_id, startup_nodes, opt)
return rc
end
local redis_instance = redis_cluster_init();
]]

local redis = require("resty.redis");
--local redis = require "redis"
-- 创建一个redis对象实例。在失败，返回nil和描述错误的字符串的情况下
local redis_instance = redis:new();
--设置后续操作的超时（以毫秒为单位）保护，包括connect方法
redis_instance:set_timeout(1000)
--建立连接
local ip = '192.168.142.142'
local port = 6323
--尝试连接到redis服务器正在侦听的远程主机和端口
local ok,err = redis_instance:connect(ip,port)
if not ok then
ngx.say("connect redis error : ",err)
return close_redis(redis_instance);
end

-- local redis = require "redis"

-- 加载nginx—lua限流模块
local limit_req = require "resty.limit.req"
-- 这里设置rate=50个请求/每秒，漏桶桶容量设置为1000个请求
-- 因为模块中控制粒度为毫秒级别，所以可以做到毫秒级别的平滑处理
local lim, err = limit_req.new("my_limit_req_store", 2, 10)
if not lim then
ngx.log(ngx.ERR, "failed to instantiate a resty.limit.req object: ", err)
return ngx.exit(501)
end

local key = ngx.var.binary_remote_addr
local delay, err = lim:incoming(key, true)

ngx.say("计算出来的延迟时间是：")
ngx.say(delay)

--if ( delay <0 or delay==nil ) then
--return ngx.exit(502)
--end

--先死这个值为-1, 就是先不限流, 先测试下面的乐观锁代码。
--delay = -1

-- 1000以外的就溢出，回绝掉，比如100000个人来抢购，那么100000-1000的请求直接nginx回绝
if not delay then
if err == "rejected" then
return ngx.say("1000以外的就溢出")
-- return ngx.exit(502)
end
ngx.log(ngx.ERR, "failed to limit req: ", err)
return ngx.exit(502)
end

-- 计算出要等很久，比如要等10秒的， 也直接不要他等了。要买家直接回家吃饭去
if ( delay >10) then
ngx.say("抢购超时")
return
end

--先到redis里面添加sku_num键（参与秒杀的该商品的数量）
--并到redis里面添加watch_key键（用于做乐观锁之用）

local resp, err = redis_instance:get("{miaosha}sku_num")
local watch_key, err = redis_instance:get("{miaosha}watch_key")
resp = tonumber(resp)
ngx.say("sku_num:")
ngx.say(resp)
if (resp > 0) then
--ngx.say("抢购成功")
redis_instance:watch("{miaosha}watch_key");
ngx.sleep(1)
local ok, err = redis_instance:multi();
local sku_num = tonumber(resp) - 1;
redis_instance:set("{miaosha}sku_num",sku_num);
redis_instance:set("{miaosha}watch_key",watch_key+1);
ans,err = redis_instance:exec()

if (tostring(ans) == "userdata: NULL") then
    ngx.say("抢购失败,慢一丁点")
    return
    
else
    ngx.say("抢购成功")
    return
end

else
ngx.say("抢购失败,手慢了")
return
end

--下面这行代码是进入正式下单;
ngx.exec('/create_order'); --注意这行代码前面不能执行ngx.say()

--[[
--每个用户限购1个,判断用户是否已经抢购过了的参考代码逻辑思路如下（具体过程略,前端缓存中也有这个类似的判断用于限制对后端的请求）：

建一张用于保存已经抢购成功了的用户的redis哈希表

抢购前判断是否在该表中
local res, err = redis_instance:hmget("myhash", "user_id")
抢购成功则保存到该表
local res, err = redis_instance:hmset("myhash", "user_id", "1")
--]]