lua整合redis

文章目录

lua
- 基础只适合
- lua连接操作redis
- - 1.下载lua依赖
  - 2.导包,连接
  - 3.常用的命令
  - - 1.set,get,push命令
  - 2.自增
  - 管道命令
  - 命令集合
  - 4.使用redis操作lua
  - - 1.实现秒杀功能
    - - synchronized关键字
    - 分布式锁

lua

基础只适合

1.编译

-- 编译
luac a.lua
-- 运行
lua a.lua

2.命名规范

-- 多行注释
'--[[]]--'
-- 单行注释
'--'
--定义类型的不用类型修饰,每行代码结束的时候用不用分号都行,变量类型可以随意改变,区分大小写

变量类型

默认创建的都是全局变量

局部变量用local关键字

3.基本数据类型

nil,boolean,number,string,function,userdata,thread,table
--type函数返回类型
print(type(args))
--[[
number:包含int,long double,float等数字类型    
]]--

lua连接操作redis

先保证自己已经有lua的依赖

1.下载lua依赖

#在终端执行,该命令下载此依赖
luarocks install redis-lua

2.导包,连接

local redis = require("redis")
--连接 host是你部署redis的ip,port是你的redis端口
local client = redis.connect(host,port);
-- 如果有密码使用密码进行连接,password填入你的redis密码
local authResult = client:auth(password)
-- 这里的authResult会返回通过该密码是不是认证成功
--检查是否连接成功,如果response为true则连接成功
local response = client:ping()

3.常用的命令

1.set,get,push命令

--set命令,这里的和redis的相对应
client:set(key,value)
--get 获取的值就是刚才传入的value
local value = client:get(key)
--向名称为key的list中压入一个元素v
client:rpush(key,value)
-- 从名称为key的list中弹出一个元素
local v = client:lpop(key)
--相当于队列这个概念,先进先出
--设置key的过期时间
client:expire("lxy",10000)

2.自增

--进行自增,使key自增1
client:incr(key)
--增加指定数量
client:set("***",1)
client:incrby("***",10)
local v = client:get("***")
print(v) --v = 11

管道命令

--将多条命令放到一个队列里面执行
local replies = client:pipeline(function(p)
    p:incrby('counter', 10)
    p:incrby('counter', 30)
    p:get('counter')
end)

命令集合

punsubscribe
expireat
info
slowlog
rpush
time
psetex
monitor
zincrby
lrange
psubscribe
zrevrangebyscore
srandmember
zscore
flushdb
mset
ping
zrank
move
lastsave
bgsave
save
slaveof
client
hgetall
hmset
exists
lpushx
sadd
getrange
hvals
hmget
zcard
renamenx
sunionstore
zrange
pttl
rpushx
zcount
lindex
substr
publish
rpoplpush
scard
keys
pexpireat
brpop
subscribe
zinterstore
unwatch
sinterstore
dbsize
zunionstore
setnx
getset
decrby
exec
config
lpop
sdiffstore
sunion
incrbyfloat
rename
select
sdiff
discard
echo
spop
setbit
multi
del
hkeys
getbit
hlen
strlen
hexists
decr
hdel
ttl
append
hincrbyfloat
hincrby
bgrewriteaof
set
zrevrank
brpoplpush
setex
zrangebyscore
hsetnx
sinter
blpop
unsubscribe
incr
zremrangebyrank
zremrangebyscore
get
flushall
randomkey
rpop
eval
zrem
incrby
zadd
srem
smembers
setrange
sort
evalsha
lrem
watch
sismember
smove
pexpire
type
script
linsert
hset
expire
zrevrange
lset
ltrim
llen
lpush
hget
persist
msetnx
mget
auth

4.使用redis操作lua

1.实现秒杀功能

因为秒杀这整个过程不是原子性的所以可以用lua脚本优化

模拟操作

//先将商品id为1库存设置为1000
set good:1 1000
    @RestController
public class controller {
    @Autowired
    private StringRedisTemplate redisTemplate;
    @GetMapping("/test")
    private String test(String idx){
        //得到对应的商品key
        String key="goods:"+idx;
        //获取商品剩余数量
        Integer amount = Integer.parseInt(redisTemplate.opsForValue().get(key));
        //如果又剩余就购买成功对应数量-1
        if(amount >1){
            redisTemplate.opsForValue().set(key, String.valueOf(--amount));
            return "success";
        }else{
            //否则这返回失败
            return "fault";
        }
    }

上面的代码在单线程下不会出现问题,但是在多线程的时候如果同时访问这个接口,因为这个操作不是原子的所以可能导致
用户1和用户2同时购买他们获取的amount都为1000 用户1买完后填入999用户2买完后填入999这就导致商品数量和购买数量不一致
这时我们就可以采用lua脚本来模拟上述过程,

synchronized关键字

@RestController
public class controller {
    @Autowired
    private StringRedisTemplate redisTemplate;
    @GetMapping("/test")
    private String test(@RequestParam("idx") String idx) {
        synchronized (this) {
            String key = "good:" + idx;
            String s = redisTemplate.opsForValue().get(key);
            System.out.println("s:" + s);
            Integer amount = Integer.parseInt(s);
            if (amount > 1) {
                redisTemplate.opsForValue().set(key, String.valueOf(--amount));
                return "success";
            } else {
                return "fault";
            }
        }
    }
}

使用synchronized关键字锁住上面代码块,这样写的效果就是同一时间只能有一个对象能执行该代码块,但是还是存在问题,如果采用集群模式,那么每台服务器都有自己的jvm这时上锁就会失败,因为锁的信息都存各自的jvm里面

分布式锁

当有多个线程要访问某一资源,为了协调多个线程的同步访问,此时就需要使用分布式锁了

具体的思想就是让线程在访问共享变量之前先获取到一个令牌token,只有具有了令牌的线程才可以访问共享资源,这个令牌就是通过各种方式实现的分布式锁,这种分布式锁是一种互斥锁,就是只要有线程抢到了锁,那么其他线程只能等待,知道锁被释放或等待超时

redis实现

利用redis中的setnx命令实现,setnx是如果存在的话就不会创建成功,不存在才能创建成功下面是对应的逻辑代码

@RestController
public class controller {
    private final String lockKey ="lock";
    @Autowired
    private StringRedisTemplate redisTemplate;
    @GetMapping("/test")
    private String test(@RequestParam("idx") String idx) {
        try {
            //获取锁
            Boolean lock = redisTemplate.opsForValue().setIfAbsent(lockKey, "***");
            if(!lock){
                return "未抢占到锁";
            }
            String key = "good:" + idx;
            String s = redisTemplate.opsForValue().get(key);
            System.out.println("s:" + s);
            Integer amount = Integer.parseInt(s);
            if (amount > 1) {
                redisTemplate.opsForValue().set(key, String.valueOf(--amount));
                return "success";
            } else {
                return "fault";
            }
        }finally {
            //释放锁
            redisTemplate.delete(lockKey);
        }
    }

}

上面使用setnx来当锁,但是仍然是存在问题的,比如在finally语句执行前服务器直接宕机了,那么这个锁就得不到释放,就没人能获取锁了,

解决方案

1.使用超时剔除

@RestController
public class controller {
    private final String lockKey ="lock";
    @Autowired
    private StringRedisTemplate redisTemplate;
    @GetMapping("/test")
    private String test(@RequestParam("idx") String idx) {
        try {
            //获取锁,设置过期时间
            Boolean lock = redisTemplate.opsForValue().setIfAbsent(lockKey, "***", Duration.ofSeconds(5));
            if(!lock){
                return "未抢占到锁";
            }
            String key = "good:" + idx;
            String s = redisTemplate.opsForValue().get(key);
            System.out.println("s:" + s);
            Integer amount = Integer.parseInt(s);
            if (amount > 1) {
                redisTemplate.opsForValue().set(key, String.valueOf(--amount));
                return "success";
            } else {
                return "fault";
            }
        }finally {
            //释放锁
            redisTemplate.delete(lockKey);
        }
    }

}

上面的代码还是存在问题,如果还没到获取商品的数量的时候key就被剔除了,那么下个线程获取到锁后,这个线程到了释放阶段,这时就会把其他线程的锁释放掉.

解决方案

//将lock的key设置成唯一标识,在释放的时候判断是不是自己的锁如果是自己的才进行释放
@RestController
public class controller {
    private final String lockKey ="lock";
    @Autowired
    private StringRedisTemplate redisTemplate;
    @GetMapping("/test")
    private String test(@RequestParam("idx") String idx) {
        String uuid = UUID.randomUUID().toString();
        try {
            //获取锁
            Boolean lock = redisTemplate.opsForValue().setIfAbsent(lockKey, uuid, Duration.ofSeconds(5));
            if(!lock){
                return "未抢占到锁";
            }
            String key = "good:" + idx;
            String s = redisTemplate.opsForValue().get(key);
            System.out.println("s:" + s);
            Integer amount = Integer.parseInt(s);
            if (amount > 1) {
                redisTemplate.opsForValue().set(key, String.valueOf(--amount));
                return "success";
            } else {
                return "fault";
            }
        }finally {
            //判断是不是自己的锁
            if(uuid.equals(redisTemplate.opsForValue().get(lockKey))) {
                //释放锁
                redisTemplate.delete(lockKey);
            }
        }
    }
}

上面的解决方案还是会存在问题,如果进入了if判断里面,还没有释放锁的哪一步,这时有个线程加锁了,那么接下来释放锁还是会释放其他线程的锁.

finally {
            //判断是不是自己的锁
            if(uuid.equals(redisTemplate.opsForValue().get(lockKey))) {
                //到了这一步,这时有现成创建了锁
                //释放锁,这时就会释放其他线程的锁
                redisTemplate.delete(lockKey);
            }
        }

关键的问题就是上面的代码不具有原子性,我们可以通过事务或者lua脚本

我们这里讲使用lua脚本

//redis执行lua的命令:eval script numkeys [key[key...]][args[args...]]
//script:要执行的lua脚本
//numkeys:key的数量
//[key[key...]]:要操作的key
//[args[args..]]:传入的参数  
eg:eval "return KEYS[2]" 3 name age depart aaa bbb ccc
//执行结果为age

接下来我们修改一下逻辑,先编写一个简单的lua脚本

--获取第一个key,也就是lock的key
local lock = KEYS[1]
-- 获取第一个参数用户的uuid
local uuid = ARGV[1]
--判断是否相等
-- redis.call("要执行的redis命令","对应的参数")
-- 获取locK对应的value
local v = redis.call("get",lock)
--  如果是该用户的锁就进行解锁
if v == uuid then
    --进行删除num接受收影响的行数
   local num =  redis.call("del",lock)
    return num
end
return 0

上面的脚本就是实现我们上面的释放锁的逻辑下面来编写代码逻辑

我这里放到了这个路径

@RestController
public class controller {
    private final String lockKey ="lock";
    @Autowired
    private StringRedisTemplate redisTemplate;
    @GetMapping("/test")
    private String test(@RequestParam("idx") String idx) {
        String uuid = UUID.randomUUID().toString();
        try {
            //获取锁
            Boolean lock = redisTemplate.opsForValue().setIfAbsent(lockKey, uuid, Duration.ofSeconds(5));
            if(!lock){
                return "未抢占到锁";
            }
            String key = "good:" + idx;
            String s = redisTemplate.opsForValue().get(key);
            System.out.println("s:" + s);
            Integer amount = Integer.parseInt(s);
            if (amount > 1) {
                redisTemplate.opsForValue().set(key, String.valueOf(--amount));
                return "success";
            } else {
                return "fault";
            }
        }finally {
            //这里就是加载对应的lua脚本
            DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
            //这里填写你的脚本地址
            redisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("lua/"+"Test.lua")));
            redisScript.setResultType(Long.type);
            String result = "";
            String argsone = "none";
            //logger.error("开始执行lua");
            try {
                //第一个参数是对应的脚本,第二个是对应的key,第三个参数是对应的args
                result = redisTemplate.execute(redisScript, Arrays.asList(lockKey),uuid);
            } catch (Exception e) {
               // logger.error("发生异常",e);
            }
        }
    }

}

上面的代码代码就能实现我们想要的结果,还有其他问题,锁提前到期的问题,锁到期小于业务执行时间,

可以写一个lua代码实现库存减少

local key = KEYS[1]
local res = redis.call("exists",key)
if res == false then
    return 0;
end
local amount = tonumber(redis.call("get",key))
if amount >0 then
     res = redis.call("decr",key)
    return res
end
return 0

我们可以封装一个工具类来执行lua脚本

package com.lxy.lualearn.demos.web;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.scripting.support.ResourceScriptSource;

import java.util.Collections;
import java.util.List;

@Component
public class LuaUtils {
    @Autowired
    private StringRedisTemplate redisTemplate;
    public boolean exect(String filePath, List<String> keys,String args){
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource(filePath)));
        redisScript.setResultType(Long.TYPE);
        Long result ;
        String argsone = "none";
        //logger.error("开始执行lua");
        try {
            result = redisTemplate.execute(redisScript, keys,args);
            return  result>0;
        } catch (Exception e) {
            // logger.error("发生异常",e);
            e.printStackTrace();
        }
        return false;
    }
}

执行一下

@RestController
public class controller {
    private final String lockKey ="lock";
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private LuaUtils luaUtils;
    @GetMapping("/test")
    private String test(@RequestParam("idx") String idx) {
            boolean exect = luaUtils.exect("/lua/Test1.lua", Collections.singletonList("goods:" + idx), "");
            return exect ? "success" : "error";
    }
}