Redis实现分布式锁——通过setExNx(互斥锁)实现

使用redis实现分布式锁，利用上面两个命令的特性。但是最重要的是锁要有过期时间，不然万一服务器宕机或者redis宕机，redis锁将永远得不到释放，出现死锁，其他线程一直获取不到资源。为了避免这种情况发生就必须保证这两个命令setnx与setex(设置过期时间)执行的原子性。

setnx,setex连用实现分布式锁

使用redis实现分布式锁，利用上面两个命令的特性。但是最重要的是锁要有过期时间，不然万一服务器宕机或者redis宕机，redis锁将永远得不到释放，出现死锁，其他线程一直获取不到资源。为了避免这种情况发生就必须保证这两个命令setnx与setex(设置过期时间)执行的原子性。

还有一个问题就是如果设置了过期时间，但是线程a在过期时间内没有执行完，这时可能会出现：
B执行到一半，serverA才执行完，这是serverA会释放serverB的锁，会导致无锁。
解决方法保证释放删除得锁与当前锁住得锁是同一个资源，即key，value完全一样，可通过lua脚本，getValue和delKey是一个原子性操作。

解决办法

lua脚本实现setnx,setex两个命令的原子性
读取lua脚本

/**
     * 获取lua结果
     * @param key
     * @param value
     * @return
     */
    public Boolean luaExpress(String key,String value) {
        lockScript = new DefaultRedisScript<Boolean>();
        lockScript.setScriptSource(
                new ResourceScriptSource(new ClassPathResource("add.lua")));
        lockScript.setResultType(Boolean.class);
        // 封装参数
        List<Object> keyList = new ArrayList<Object>();
        keyList.add(key);
        keyList.add(value);
        Boolean result = (Boolean) redisTemplate.execute(lockScript, keyList);
        Long expire = redisTemplate.getExpire(key);
        System.out.println("超时时间："+expire);
        return result;
    }

lua脚本：

local lockKey = KEYS[1]
local lockValue = KEYS[2]

-- setnx info
local result_1 = redis.call('SETNX', lockKey, lockValue)
if result_1 == 1 then
local result_2= redis.call('SETEX', lockKey, 3600, lockValue)
return result_1
else
return result_1
end

lua脚本保证释放的是当前锁

/**
     * 释放锁操作
     * @param key
     * @param value
     * @return
     */
    private boolean releaseLock(String key, String value) {
        lockScript = new DefaultRedisScript<Boolean>();
        lockScript.setScriptSource(
                new ResourceScriptSource(new ClassPathResource("unlock.lua")));
        lockScript.setResultType(Boolean.class);
        // 封装参数
        List<Object> keyList = new ArrayList<Object>();
        keyList.add(key);
        keyList.add(value);
        Boolean result = (Boolean) redisTemplate.execute(lockScript, keyList);
        return result;
    }

unlock.lua

local lockKey = KEYS[1]
local lockValue = KEYS[2]

-- get key
local result_1 = redis.call('get', lockKey)
if result_1 == lockValue then
local result_2= redis.call('del', lockKey)
return result_2
else
return false
end

通过setExNx(互斥锁)实现

定义Lua脚本：
在resources目录下创建lua目录，并且创建redisLock.lua文件；

if redis.call('get',KEYS[1]) == ARGV[1] then
     redis.call('del', KEYS[1])
     return '1';
else
    return '0'
end

Lua脚本配置：

import org.springframework.context.annotation.Configuration;
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 javax.annotation.Resource;
import java.util.Collections;
import java.util.List;

@Configuration
public class RedisLuaConfig {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /**
     * @return result 返回 1表示，正常，0表示限制访问
     */
    public boolean runLuaScript(String lockKey, String value) {
        List<String> keyList = Collections.singletonList(lockKey);

        // 执行脚本 删除锁
        DefaultRedisScript<String> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("lua/redisLock.lua")));
        redisScript.setResultType(String.class);
        String execute = stringRedisTemplate.execute(redisScript, keyList, value);
        return "1".equals(execute);
    }
}

Lock锁配置：

@Component
public class RedisLockServer {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Resource
    private RedisLuaConfig redisLuaConfig;

    public boolean setLock(String lockKey, String value, long time, TimeUnit timeUnit) {
        return stringRedisTemplate.opsForValue().setIfAbsent(lockKey, value, time, timeUnit);
    }

    public void deleteLock(String lockKey, String value) {
        boolean script = redisLuaConfig.runLuaScript(lockKey, value);
    }
}

逻辑代码实现：
为了验收方便，在controller层进行业务的编写，测试时，通过浏览器频繁刷新进行请求，模拟锁机制的触发；

@RestController
@RequestMapping("/redis")
public class Test {
    @Resource
    private RedisLockServer redisLockServer;

    @RequestMapping(value = "/lock")
    public String reduceSku() throws Exception {
        String value = UUID.randomUUID().toString();
        // value值任意即可，设置自动过期时间为10S
        boolean lock = redisLockServer.setLock("key", value, 10, TimeUnit.SECONDS);
        if (lock) {
            // 当前key没有锁，加锁成功 执行数据库查询
            System.out.println("===>>>加锁成功");

            // 模拟耗时8S
            TimeUnit.SECONDS.sleep(8);

            // 所以要保证验证value值和验证成功必须满足原子性，通过redis+lua实现
            redisLockServer.deleteLock("key", value);
        } else {
            // 当前key已经存在锁，加锁失败
            System.out.println("===>>>加锁失败,等待重试...");
        }
        return "操作成功";
    }
}

效果：

image.png