redis 可用于分布式事务锁：

import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@Component
public class RedisLock {
    


    @Autowired
    private RedisTemplate redisTemplate;


    private static Map<String, LockInfo> lockInfoMap = new ConcurrentHashMap<>();


    @Data
    public static class LockInfo {
    

        private String key;

        private String identity;

        private int expireTime;

        //更新时间
        private long renewalTime;

        //更新间隔
        private long renewalInterval;

        public static LockInfo getLockInfo(String key, String identity, int expireTime) {
    
            LockInfo lockInfo = new LockInfo();
            lockInfo.setKey(key);
            lockInfo.setIdentity(identity);
            lockInfo.setExpireTime(expireTime);
            lockInfo.setRenewalTime(System.currentTimeMillis());
            lockInfo.setRenewalInterval(expireTime * 2000 / 3);
            return lockInfo;
        }
    }


    /**
     * 获取锁
     *
     * @param lockKey    锁
     * @param identity   身份标识（保证锁不会被其他人释放）
     * @param expireTime 锁的过期时间（单位：秒）
     * @return
     */
    public boolean tryLock(String lockKey, String identity, int expireTime) {
    
        boolean ret = false;
        try {
    
            String script = "if redis.call('setNx',KEYS[1],ARGV[1]) then if redis.call('get',KEYS[1])==ARGV[1] then return redis.call('expire',KEYS[1],ARGV[2]) else return 0 end end";

            RedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);
            Object result = redisTemplate.execute(redisScript, new StringRedisSerializer(), new StringRedisSerializer(), Collections.singletonList(lockKey), identity, expireTime);
            System.out.println(result + "-----------");
            //Object result = redisTemplate.execute(redisScript, Collections.singletonList(lockKey),value,expireTime + "");

            if (Long.valueOf(1L).equals(result)) {
    
                return true;
            }

            if (expireTime >= 10) {
    
                lockInfoMap.put(lockKey + identity, LockInfo.getLockInfo(lockKey, identity, expireTime));
            }

        } catch (Exception e) {
    
            e.printStackTrace();
        }
        return ret;
    }

    /**
     * 释放锁
     *
     * @param lockKey
     * @param identity
     * @return
     */
    public boolean unlock(String lockKey, String identity) {
    

        lockInfoMap.remove(lockKey + identity);

        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        RedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);

        Object result = redisTemplate.execute(redisScript, new StringRedisSerializer(), new StringRedisSerializer(), Collections.singletonList(lockKey), identity);
        if (Long.valueOf(1L).equals(result)) {
    
            return true;
        }

        return false;
    }


    /**
     * 更新redis锁的过期时间
     *
     * @param lockKey
     * @param identity
     * @return
     */
    public boolean renewal(String lockKey, String identity, int expireTime) {
    

        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('expire', KEYS[1], ARGV[2]) else return 0 end";
        RedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);
        Object result = redisTemplate.execute(redisScript, new StringRedisSerializer(), new StringRedisSerializer(), Collections.singletonList(lockKey), identity, expireTime);
        if (Long.valueOf(1L).equals(result)) {
    
            return true;
        }
        return false;
    }


    /**
     * Lua脚本
     * // 加锁
     * if
     *     redis.call('setNx',KEYS[1],ARGV[1])
     *   then
     *     if redis.call('get',KEYS[1])==ARGV[1]
     *     return redis.call('expire',KEYS[1],ARGV[2])
     *   else
     *     return 0
     *   end
     * end
     *
     * // 解锁
     *   redis.call('get', KEYS[1]) == ARGV[1]
     * then
     *   return redis.call('del', KEYS[1])
     * else
     *   return 0
     */


    /**
     * 获取锁
     *
     * @param lockKey    锁
     * @param identity   身份标识（保证锁不会被其他人释放）
     * @param expireTime 锁的过期时间（单位：秒）
     * @return
     */
    public boolean lock(String lockKey, String identity, long expireTime) {
    
        return redisTemplate.opsForValue().setIfAbsent(lockKey, identity, expireTime, TimeUnit.SECONDS);

    }

    /**
     * 释放锁
     *
     * @param lockKey  锁
     * @param identity 身份标识（保证锁不会被其他人释放）
     * @return
     */
    public boolean releaseLock(String lockKey, String identity) {
    
        String luaScript = "if " +
                "  redis.call('get', KEYS[1]) == ARGV[1] " +
                "then " +
                "  return redis.call('del', KEYS[1]) " +
                "else " +
                "  return 0 " +
                "end";
        DefaultRedisScript<Boolean> redisScript = new DefaultRedisScript<>();
        redisScript.setResultType(Boolean.class);
        redisScript.setScriptText(luaScript);
        List<String> keys = new ArrayList<>();
        keys.add(lockKey);
        Object result = redisTemplate.execute(redisScript, keys, identity);
        return (boolean) result;
    }


    /**
     * @author wangshbv
     * 
     * @Desc 定时去检查redis锁的过期时间
     * @Param
     * @Return
     */
    @Scheduled(fixedRate = 5000L)
    @Async("redisExecutor")
    public void renewal() {
    
        long now = System.currentTimeMillis();
        for (Map.Entry<String, LockInfo> lockInfoEntry : lockInfoMap.entrySet()) {
    
            LockInfo lockInfo = lockInfoEntry.getValue();
            if (lockInfo.getRenewalTime() + lockInfo.getRenewalInterval() < now) {
    
                renewal(lockInfo.getKey(), lockInfo.getIdentity(), lockInfo.getExpireTime());
                lockInfo.setRenewalTime(now);
            }
        }
    }

    /**
     * @author wangshbv
     * @Date 2021/11/19 17:08
     * @Desc 分布式锁设置单独线程池
     * @Param
     * @Return
     */
    @Bean("redisExecutor")
    public Executor redisExecutor() {
    
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(1);
        executor.setMaxPoolSize(1);
        executor.setQueueCapacity(1);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("redis-renewal-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());
        return executor;
    }
}