Redis分布式锁

beanUtil

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

/**
 * spring bean工具类，支持通过静态方法从容器中获取bean
 *
 * @author dengxiaoming
 * @date 2019-12-26
 */
public class SpringBeanUtil implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringBeanUtil.applicationContext = applicationContext;
    }

    public static  T getBean(Class clazz) {
        if (applicationContext == null) {
            return null;
        }
        return applicationContext.getBean(clazz);
    }

    public static Object getBean(String name) throws BeansException {
        if (applicationContext == null) {
            return null;
        }
        return applicationContext.getBean(name);
    }

    public static ApplicationContext getCtx() throws BeansException {
        return applicationContext;
    }
}

RedisUtil

import java.time.Duration;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;

/**
 * Redis工具类
 *
 * @author dengxiamoing
 * @date 2020-02-19 15:40
 */
@SuppressWarnings("unchecked")
public class RedisUtil {

    private static RedisTemplate redisTemplate;

    /**
     * 获取redisTemplate
     * 

     * redisTemplate为空时从spring上下文中获取
     *
     * @return redisTemplate
     */
    public static RedisTemplate getRedisTemplate() {
        if (redisTemplate == null) {
            synchronized (RedisUtil.class) {
                if (redisTemplate == null) {
                    redisTemplate = (RedisTemplate) SpringBeanUtil.getBean("x7RedisTemplate");
                }
            }
        }

        return redisTemplate;
    }

    /**
     * 对字符串类型的数据操作
     *
     * @return string类型操作对象
     */
    public static ValueOperations valueOps() {
        return getRedisTemplate().opsForValue();
    }

    /**
     * 对hash类型的数据操作
     *
     * @return hash类型操作对象
     */
    public static HashOperations hashOps() {
        return getRedisTemplate().opsForHash();
    }

    /**
     * 对列表类型的数据操作
     *
     * @return list类型操作对象
     */
    public static ListOperations listOps() {
        return getRedisTemplate().opsForList();
    }

    /**
     * 对集合类型的数据操作
     *
     * @return set类型操作对象
     */
    public static SetOperations setOps() {
        return getRedisTemplate().opsForSet();
    }

    /**
     * 对有序集合类型的数据操作
     *
     * @return zset类型操作对象
     */
    public static ZSetOperations zSetOps() {
        return getRedisTemplate().opsForZSet();
    }

    /**
     * 删除指定键值数据
     *
     * @param key 键值
     */
    public static void delete(String key) {
        getRedisTemplate().delete(key);
    }

    /**
     * 批量删除指定键值数据
     *
     * @param keys 键值列表
     */
    public static void delete(List keys) {
        getRedisTemplate().delete(keys);
    }

    /**
     * 指定键值超时时间
     *
     * @param key        键值
     * @param expireTime 超时时间
     */
    public static void expire(String key, Duration expireTime) {
        getRedisTemplate().expire(key, expireTime.toMillis(), TimeUnit.MILLISECONDS);
    }
}

RedisLock

import io.netty.util.HashedWheelTimer;
import java.util.Collections;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.core.script.DefaultRedisScript;

/**
 * @author mojiazhu
 * @date 2023/7/21 13:49
 */
public class RedisLock {

    private final String redisKey;

    public RedisLock(String redisKey) {
        this.redisKey = redisKey;
    }

    /**
     * 一直尝试加锁 可重入标识为 线程id
     */
    public void lock() {
        String reentryFlag = String.valueOf(Thread.currentThread().getId());
        lock(reentryFlag);
    }

    /**
     * 尝试一段时间枷锁 可重入标识为 线程id
     *
     * @param SpinTime 获取锁超时时间
     */
    public void tryLock(int SpinTime) {
        String reentryFlag = String.valueOf(Thread.currentThread().getId());
        tryLock(reentryFlag, SpinTime);
    }

    /**
     * 释放锁 可重入标识为 线程id
     */
    public void unLock() {
        String reentryFlag = String.valueOf(Thread.currentThread().getId());
        unLock(reentryFlag);
    }

    /**
     * 一直尝试加锁 可重入标识为 自定义标识
     */
    public void lock(String reentryFlag) {
        int expireTime = 30 * 1000;
        while (true) {
            boolean acquire = tryAcquire(reentryFlag, expireTime);
            if (acquire) {
                autoRenewal(reentryFlag);
                return;
            }

            //后期请修改以下方法 休眠时间果断 线程多会长期占用cpu
            try {
                LockSupport.parkNanos(10);
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }


    /**
     * 尝试一段时间枷锁 可重入标识为 自定义标识
     *
     * @param SpinTime 获取锁超时时间
     */
    public boolean tryLock(String reentryFlag, int SpinTime) {
        int spinTime = 0;
        int expireTime = 30 * 1000;
        while (true) {
            if (spinTime > SpinTime) {
                return false;
            }
            boolean isGet = tryAcquire(reentryFlag, expireTime);
            if (isGet) {
                autoRenewal(reentryFlag);
                return true;
            }
            try {
                Thread.sleep(1000);
                spinTime++;
            } catch (Exception e) {
                return false;
            }
        }
    }

    /**
     * 释放锁 可重入标识为 自定义标识
     */
    public void unLock(String reentryFlag) {
        DefaultRedisScript