问题背景

Redisson做分布式锁是目前比较流行的方式，但是在使用的过程中遇到一些坑：

Redisson的分布式锁只能通过创建锁的线程进行解锁，正所谓解铃还须系铃人，不是同一个线程解锁会报异常
因为Redisson是为锁而生，所以一开始设计的时候，为了防止死锁，默认锁的过期时间为30S
当时我居然傻到用单元测试来测试Redisson的分布式锁，我太傻了，单元测试之后马上就会结束项目运行，那么就没有线程持有锁了，更别说还需要同线程解锁了

但我的项目中做了分布式任务调度，定时去扫描任务完成没有，完成了再进行解锁，但定时的扫描线程不是之前的加锁线程了，所以使用redisson做分布式锁不太合适，本篇介绍redis的分布式锁的模板使用

注意事项：

代码是从我的这篇文章进行添加修改的
可以自己创建工程，也可以下载源码进行参考
默认已安装redis，可以使用安装包安装看这篇文章，使用docker安装看这篇文章

项目搭建

1 在RedisUtils工具类中添加setNX方法，value值可以设置为globalId，这样具有唯一性，每次解锁还有增加一层value的判断保证更安全

package com.yg.redisson.utils;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.types.Expiration;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Service;

import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.TimeUnit;



/**
 * @Author suolong
 * @Date 2022/4/26 13:33
 * @Version 2.0
 */

@Service("redisUtils")
@Slf4j
public class RedisUtils {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
       try {
           return key == null ? null : redisTemplate.opsForValue().get(key);
       }catch (Exception ex){
           log.error("获取缓存异常", ex);
           return null;
       }
    }

    public boolean del(String key){
        try {
          return Boolean.TRUE.equals(redisTemplate.delete(key));
        }catch (Exception e){
            log.error("删除缓存键异常",e);
            return false;
        }
    }

    public Long increment(String key, Long delta){
        try {
            return redisTemplate.opsForValue().increment(key, delta);
        }catch (Exception ex){
            log.error("操作缓存异常",ex);
            return null;
        }
    }

    public void saveByPipeLine(Map<String, Map<String, String>> dataMap){
        try {
            final RedisSerializer keySerializer = redisTemplate.getKeySerializer();
            final RedisSerializer valueSerializer = redisTemplate.getValueSerializer();
            redisTemplate.executePipelined((RedisCallback<Object>) redisConnection -> {
               dataMap.forEach((key,value) -> redisConnection.set(Objects.requireNonNull(keySerializer.serialize(key)), Objects.requireNonNull(valueSerializer.serialize(value)), Expiration.seconds(6 * 3600), RedisStringCommands.SetOption.UPSERT));
                return null;
            });
        }catch (Exception ex){
            log.error("pipeline存储异常",ex);
        }
    }


    public void saveByPipeLineMap(Map<String, String> dataMap, String key){
        try {
            final RedisSerializer keySerializer = redisTemplate.getKeySerializer();
            final RedisSerializer valueSerializer = redisTemplate.getValueSerializer();
            redisTemplate.executePipelined((RedisCallback<Object>) redisConnection -> {
                redisConnection.set(Objects.requireNonNull(keySerializer.serialize(key)), Objects.requireNonNull(valueSerializer.serialize(dataMap)), Expiration.seconds(6 * 3600), RedisStringCommands.SetOption.UPSERT);
                return null;
            });
        }catch (Exception ex){
            log.error("pipeline存储异常",ex);
        }
    }

    public List<Object> getByPipeLine(List<String> keys){
        try {
            return redisTemplate.executePipelined((RedisCallback<Object>) redisConnection -> {
                for (String key : keys) {
                    redisConnection.get(key.getBytes(StandardCharsets.UTF_8));
                }
                return null;
            });
        }catch (Exception ex){
            log.error("pipeline读取异常",ex);
        }
        return Collections.emptyList();
    }

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            log.error("设置缓存异常:{}",e.getLocalizedMessage());
            return false;
        }
    }

    public Long del(Set<String> key) {
        try {
            if (CollectionUtils.isNotEmpty(key)) {
                return redisTemplate.delete(key);
            }
            return null;
        }catch (Exception ex){
            log.error("删除缓存键异常:{}", ex.getLocalizedMessage());
            return null;
        }
    }

	//设置锁名，value值，过期时间
    public boolean setNX(String lockKey, String value, long expiryTime) {
        if (redisTemplate == null) {
            log.info("redisTemplate is null");
            return false;
        }

        try {
            Boolean flag = redisTemplate.opsForValue().setIfAbsent(lockKey, value, expiryTime, TimeUnit.SECONDS);
            assert flag != null;
            if (!flag) {
                log.info("加锁失败");
                return false;
            }

            log.info("Thread [{}] redisTemplate lock [{}] success", Thread.currentThread().getName(), lockKey);
            // 加锁成功
            return true;
        } catch (Exception e) {
            log.info("加锁失败", e);
            log.error("redisTemplate lock [{}] Exception:", lockKey, e);
            return false;
        }
    }
}

2 setNX测试，先设置setNX，然后进行del，此时两个方法并不是同一个线程

    @Test
    void redisDel() {
        boolean res = redisUtils.del("yuan");
        log.info("res: {}", res);
    }


    @Test
    void redisSetNX() {
        boolean res = redisUtils.setNX("yuan", "123",12*60*60L);
        log.info("res: {}", res);
    }