Redis分布式锁

最新推荐文章于 2025-03-19 22:19:39 发布
廋到被风吹走
最新推荐文章于 2025-03-19 22:19:39 发布
阅读量457
点赞数
分类专栏： Redis 文章标签： Redis
本文链接：https://blog.youkuaiyun.com/Txx318026/article/details/88698627
版权
Redis 专栏收录该内容
2 篇文章
订阅专栏
本文详细探讨了Redis作为分布式锁的实现原理，包括SET命令的NX与EX选项、Redlock算法以及分布式锁的公平性、续租与释放等问题，旨在帮助读者掌握在高并发环境下如何有效使用Redis实现可靠且高效的锁机制。
摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >
public class DistributedLockUtil {
    private static Logger logger = LoggerFactory.getLogger(DistributedLockUtil.class);

    JdRedisUtils jdCacheUtils;

    //锁名称
    private String DistributedLock = null;

    //锁的值
    private Long lockValue = null;

    //锁设置的超时时间
    private Long locktimeout = null;

    //锁设置的起始时间
    private Date setLockTime = null;


    public DistributedLockUtil(String lock,JdRedisUtils jdCacheUtil)
    {
        DistributedLock = "yn_" + lock;
        jdCacheUtils = jdCacheUtil;
    }

    /*
     * @Title: getDistributedLock
     * @Description: 获取分布式锁
     * @param lock; timeoutSec:是秒级别的超时时间。请根据实际情况设置锁的超时时间，不能随意设置。
     * 另外注意：使用完后，要及时释放锁。
     * @return true表示获取锁成功；false表示获取锁失败
     */
    public boolean getDistributedLock(Long timeoutSec)
    {
        try {
            //设置超时时间点（从当前系统时间算起）
            Date now = new Date();
            Long lockTimeout = now.getTime() + timeoutSec * 1000;

            //设置锁相关信息
            setLockTime = now;
            locktimeout = timeoutSec;
            lockValue = lockTimeout;

            //获取锁
            boolean isGetLock = jdCacheUtils.setNX(DistributedLock, lockTimeout.toString());

            //获取锁成功
            if(isGetLock == true)
            {
                try {

                    //设置锁的有效期
                    jdCacheUtils.expire(DistributedLock, timeoutSec, TimeUnit.SECONDS);

                    logger.error("正常加锁成功。lock：" + DistributedLock + ";设置锁时间:" +
                            setLockTime + ";锁超时时间：" + locktimeout + ";锁对应值：" + lockValue);
                    return true;

                } catch (Exception e) {
                    e.getStackTrace();

                    //发生异常时，需要对锁进行回滚。
                    jdCacheUtils.delete(DistributedLock);
                    logger.error("正常加锁异常失败-设置超时时间异常。lock："
                            + DistributedLock + ";设置锁时间:" +
                            setLockTime + ";锁超时时间：" + locktimeout + ";锁对应值：" + lockValue);
                    return false;
                }
            }

            //获取锁失败，判断是否需要强制解锁
            else {

                //判断是否锁已经过期
                String timeout = jdCacheUtils.get(DistributedLock);
                if(timeout == null)
                {
                    logger.error("强制解锁异常失败-获取原锁异常。lock："
                            + DistributedLock + ";设置锁时间:" +
                            setLockTime + ";锁超时时间：" + locktimeout + ";新锁对应值：" + lockValue);
                    return false;
                }

                //判断锁是否超时：锁超时。（即锁的超时时间 < 当前系统时间）
                else if(now.getTime() > Long.valueOf(timeout).longValue())
                {
                    //强制解锁
                    String forceTimeout =
                            jdCacheUtils.getSet(DistributedLock, lockTimeout.toString());
                    if((forceTimeout == null) || (forceTimeout.equals(timeout)))
                    {
                        try {

                            //设置锁的有效期
                            jdCacheUtils.expire(DistributedLock, timeoutSec, TimeUnit.SECONDS);

                        } catch (Exception e) {

                            e.getStackTrace();

                            //发生异常时，需要对锁进行回滚。
                            jdCacheUtils.delete(DistributedLock);

                            logger.error("强制解锁异常失败-设置超时时间异常。lock："
                                    + DistributedLock + ";设置锁时间:" +
                                    setLockTime + ";锁超时时间：" + timeout + ";新锁对应值：" + lockValue
                                    + "原锁对应值：" + timeout);

                            return false;
                        }

                        //test
                        String timeout1 = jdCacheUtils.get(DistributedLock);
                        System.out.println(timeout1);

                        logger.error("强制解锁成功。lock：" + DistributedLock + ";设置锁时间:" +
                                setLockTime + ";锁超时时间：" + locktimeout + "; 新锁对应值：" + lockValue
                                + "原锁对应值：" + timeout);

                        return true;
                    }
                    else {

                        logger.error("强制解锁异常失败。lock：" + DistributedLock + ";设置锁时间:" +
                                setLockTime + ";锁超时时间：" + locktimeout + ";新锁对应值：" + lockValue
                                + "原锁对应值：" + timeout);

                        //强制解锁失败。
                        return false;
                    }
                }
            }

            logger.error("锁已经被占用。lock：" + DistributedLock + ";设置锁时间:" +
                    setLockTime + ";锁超时时间：" + locktimeout);

            return false;

        } catch (Exception e) {
            logger.error("加锁失败-异常。lock："
                    + DistributedLock + ";设置锁时间:" +
                    setLockTime + ";锁超时时间：" + locktimeout + ";锁对应值：" + lockValue);
            e.printStackTrace();
            return false;
        }
    }


    /*
     * @Title: delDistributedLock
     * @Description: 释放获取分布式锁,采用惰性删除的方式。加锁和解锁函数必须成对出现。不能只是用解锁函数。
     * @param lock
     * @return true表示获取锁成功；false表示获取锁失败。释放锁失败则无需再做处理
     */


    public boolean delDistributedLock()
    {
        Date now = new Date();
        try {
            //1：判断是否锁已经过期
            String timeout = jdCacheUtils.get(DistributedLock);
            if(timeout == null)
            {
                //主要原因：处理业务逻辑时间太长，导致锁超时时间已到而释放。
                logger.error("正常释放锁异常失败-获取原锁异常，可能原因：业务逻辑时间太长，导致锁超时时间已到而释放，或者redis异常。lock："
                        + DistributedLock + ";设置锁时间:" +
                        setLockTime + ";锁超时时间：" + locktimeout + ";锁对应值：" + lockValue +
                        ";释放锁时间：" + now);
                return true;
            }

            //3：判断锁是否已经过期，未过期，则释放锁；如果已经过期，无需处理,已经被其它的应用强制释放锁。
            if(lockValue > now.getTime())
            {
                //释放锁
                jdCacheUtils.delete(DistributedLock);

                logger.error("正常释放锁成功。lock："
                        + DistributedLock + ";设置锁时间:" +
                        setLockTime + ";锁超时时间：" + locktimeout + ";锁对应值：" + lockValue
                        + ";释放锁时间：" + now);

                return true;
            }
            else {

                logger.error("正常释放锁失败-处理业务逻辑时间过长，锁已经超时，无需释放。lock："
                        + DistributedLock + ";设置锁时间:" +
                        setLockTime + ";锁超时时间：" + locktimeout + ";锁对应值：" + lockValue
                        + ";释放锁时间：" + now);

                return false;
            }



        } catch (Exception e) {

            logger.error("释放锁失败-异常。lock："
                    + DistributedLock + ";设置锁时间:" +
                    setLockTime + ";锁超时时间：" + locktimeout + ";锁对应值：" + lockValue
                    + ";释放锁时间：" + now);
            e.getStackTrace();
            return false;
        }
    }
}