Redis结合LUA脚本实现序列号唯一引发的问题

Redis结合LUA脚本实现序列号唯一引发的问题

背景

项目中使用redis结合lua脚本来获取序列号，保证序列号的唯一，lua脚本是我在网上找的，看好多大神都在用，也就觉得没问题，直接引入了自己的项目。脚本内容如下（本人对脚本内容添加了注释，方便读者理解）：

-- 获取最大的序列号,样例为16081817202494579
-- 从redis中获取到的序列如果小于传入的序列号,就把redis中的序列号置为当前序列号,并返回给调用者
-- 从redis中获取到的序列如果大于传入的序列号,就按照增长规则递增,并返回给调用者
-- 通过这样的方式保证序列号的唯一性

local function get_max_seq()
//KEYS[1]:第一个参数代表存储序列号的key  相当于代码中的业务类型
local key = tostring(KEYS[1])
//KEYS[2]:第二个参数代表序列号增长速度
local incr_amoutt = tonumber(KEYS[2])
//KEYS[3]:第三个参数为序列号 (yyMMddHHmmssSSS + 两位随机数)
local seq = tostring(KEYS[3])
//序列号过期时间大小
local month_in_seconds = 24 * 60 * 60 * 30

//Redis的 SETNX 命令可以实现分布式锁,用于解决高并发
//如果key不存在,将 key 的值设为 seq，设置成成功返回1   未设置返回0
//若给定的 key 已经存在，则 SETNX 不做任何动作。
if (1 == redis.call('setnx', key, seq))
then
//设置key的生存时间   为  month_in_seconds秒
redis.call('expire', key, month_in_seconds)
//将序列返回给调用者
return seq
else
//key值存在,直接获取key值大小(序列号)
local prev_seq = redis.call('get', key)
//获取到的序列号  小于 当前序列号
if (prev_seq < seq)
then
//直接将key值设为当前序列号
redis.call('set', key, seq)
//返回给调用者
return seq
else
//获取到的序列号  大于  当前序列号  就将key值置为key+incr_amoutt
redis.call('incrby', key, incr_amoutt)
//将key+incr_amoutt 返回给调用者
return redis.call('get', key)
end
end
end
return get_max_seq()

在脚本中可以使用redis.call函数调用Redis命令

在脚本中可以使用return语句将值返回给客户端，如果没有执行return语句则默认返回null

脚本优化

项目业务功能在不断扩展，redis中存放的数据也越来越多，为了更加方便的管理redis中的key，我对脚本内容进行了修改，将原有的key-value存储修改为key-hashkey-value形式存储，修改后的脚本：

local function get_max_seq()

local key = 'SEEKER:SEQ:BIZ'

local increment = 1

local hkey = tostring(KEYS[1])

local seq = tostring(KEYS[2])

local month_in_seconds = 24 * 60 * 60 * 30

if (1 == redis.call('hsetnx', key, hkey, seq))
then
redis.call('expire',key,month_in_seconds)
return seq
else
local prev_seq = redis.call('hget',key, hkey)
if(prev_seq < seq)
then
redis.call('hset',key,hkey,seq)
return seq
else
redis.call('hincrby', key, hkey, increment)
return redis.call('hget', key, hkey)
end
end
end
return get_max_seq()

高并发导致获取序列号重复

使用修改后的脚本，项目也稳定运行了半年多时间，突然有一天，运维跟我说获取的序列号重复了。于是我本地环境模拟高并发开始测试脚本，即每次传入脚本的seq参数都是固定字符串，结果获取到序列号有重复的，脚本的确有问题。

经研究：脚本中在比较字符串大小时，使用的是tostring，比较结果不准确，可能出现’24’ > ‘25’情况（具体脚本为什么不能用tostring进行比较，请读者自行查阅资料），应该使用tonumber，于是再次对脚本进行了修改。修改后脚本内容如下：

local function get_max_seq()

local key = tostring(KEYS[1])

local increment = tonumber(KEYS[2])

local hkey = tostring(KEYS[3])

local seq = tonumber(KEYS[4])

local month_in_seconds = 2592000

if (1 == redis.call('hsetnx', key, hkey, seq))
then
redis.call('expire',key,month_in_seconds)
return seq
else
local prev_seq = redis.call('hget',key, hkey)
if(tonumber(prev_seq) < seq)
then
redis.call('hset',key,hkey,seq)
return seq
else
return redis.call('hincrby', key, hkey, increment)
end
end
end
return get_max_seq()

使用修改后的脚本再进行高并发测试，序列号不会重复，问题已经解决。

总结

任何新技术的引用，都要仔细研究，亲身测试。

附：测试代码（springboot实现）

package com.seeker.controller;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.support.EncodedResource;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.core.script.DefaultScriptExecutor;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.stereotype.Component;
import org.springframework.util.FileCopyUtils;

/**
* @title
* @description
* @since Java8
*/
@Component
public class RedisUtil {

private static StringRedisTemplate redisStringTemplate;

private static RedisScript<String> redisScript;

private static DefaultScriptExecutor<String> scriptExecutor;

private RedisUtil(StringRedisTemplate template) throws IOException {
RedisUtil.redisStringTemplate = template;

// 初始化lua脚本调用 的redisScript 和 scriptExecutor
ClassPathResource luaResource = new ClassPathResource("get_next_seq.lua");
EncodedResource encRes = new EncodedResource(luaResource, "UTF-8");
String luaString = FileCopyUtils.copyToString(encRes.getReader());

redisScript = new DefaultRedisScript<>(luaString, String.class);
scriptExecutor = new DefaultScriptExecutor<>(redisStringTemplate);
}

public static String getBusiId(String type) {
List<String> keyList = new ArrayList<>();
keyList.add("24");
keyList.add("23");

String seq = scriptExecutor.execute(redisScript, keyList);
return type + seq;

}

}

package com.seeker.controller;

import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.util.Vector;
import java.util.concurrent.CountDownLatch;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.PostMethod;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import com.fasterxml.jackson.databind.ObjectMapper;

/**
*
* @author Fan.W
* @since 1.8
*/
@Controller
@RequestMapping("/seeker")
public class TestController {
private static Vector<String> s = new Vector<>();
@Autowired
private StringRedisTemplate template;

@RequestMapping(value = "/redistest")
public String redistest() {

CountDownLatch startSignal = new CountDownLatch(1);

for (int i = 0; i < 100; ++i) {
new Thread(new Task(startSignal)).start();
}

startSignal.countDown();
return "hello";
}

class Task implements Runnable {
private final CountDownLatch startSignal;

Task(CountDownLatch startSignal) {
this.startSignal = startSignal;
}

public void run() {
try {
String seq = RedisUtil.getBusiId("24");
System.out.println(seq);
if (s.contains(seq)) {
System.out.println("重复id " + seq);
} else {
s.add(seq);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}