Redis分布式锁 根据 redisTemplate创建

已于 2022-06-09 14:43:53 修改
阅读量568 收藏 1
点赞数
文章标签： redis 分布式 java
于 2022-06-09 14:30:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37351027/article/details/125202542
版权

第一种

原文地址

https://www.jb51.net/article/147617.htm

***
 * 第一种Redis 分布式锁
 */
class CommonRedisHelper {
    public static final String LOCK_PREFIX = "redis_lock";
    public static final int LOCK_EXPIRE = 300; // ms
    @Autowired
    RedisTemplate redisTemplate;

    /**
     * 最终加强分布式锁
     *
     * @param key key值
     * @return 是否获取到
     */
    public boolean lock(String key) {
        String lock = LOCK_PREFIX + key;
        // 利用lambda表达式
        return (Boolean) redisTemplate.execute((RedisCallback) connection -> {
            long expireAt = System.currentTimeMillis() + LOCK_EXPIRE + 1;
            Boolean acquire = connection.setNX(lock.getBytes(), String.valueOf(expireAt).getBytes());
            if (acquire) {
                return true;
            } else {
                byte[] value = connection.get(lock.getBytes());
                if (Objects.nonNull(value) && value.length > 0) {
                    long expireTime = Long.parseLong(new String(value));
                    if (expireTime < System.currentTimeMillis()) {
                        // 如果锁已经过期
                        byte[] oldValue = connection.getSet(lock.getBytes(), String.valueOf(System.currentTimeMillis() + LOCK_EXPIRE + 1).getBytes());
                        // 防止死锁
                        return Long.parseLong(new String(oldValue)) < System.currentTimeMillis();
                    }
                }
            }
            return false;
        });
    }

    /**
     * 删除锁
     *
     * @param key
     */
    public void delete(String key) {
        redisTemplate.delete(key);
    }

// 测试
    public static void main(String[] args) {
        String key = "1";
        CommonRedisHelper redisHelper = new CommonRedisHelper();
        boolean lock = redisHelper.lock(key);
        if (lock) {
            // 执行逻辑操作
            redisHelper.delete(key);
        } else {
            // 设置失败次数计数器, 当到达5次时, 返回失败
            int failCount = 1;
            while (failCount <= 5) {
                // 等待100ms重试
                try {
                    Thread.sleep(100L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (redisHelper.lock(key)) {
                    // 执行逻辑操作
                    redisHelper.delete(key);
                } else {
                    failCount++;
                }
            }
            throw new RuntimeException("现在创建的人太多了, 请稍等再试");
        }
    }
}

/***
 *
 *
 * 注意事项：
 *
 * 1、获取锁时设置key的value值需要保持一定的唯一性，以识别是否是加锁和解锁的线程
 *
 * 2、key对应设置生命周期expireTime，防止死锁
 *
 */

第二种

原文地址

https://blog.csdn.net/weixin_43952575/article/details/123000060

/**
 * 设置等待时间，在时间内 循环操作   第二种
 */
@Component
class RedisLockUtilWithWaittime {

    @Autowired
    private RedisTemplate redisTemplate;

    public static final String LOCKED = "TRUE";
    public static final long EXPIRE = 120L;
    public static final long ONE_MILLI_NANOS = 1000000L;
    public static final long DEFAULT_TIME_OUT = 2000L;
    public static final Random RANDOM = new Random();

    public RedisLockUtilWithWaittime() {

    }

    // 函数式接口
    public interface MainOperator<T> {
        boolean HOLD_LOCK_TAG = false;

        T executeInvokeLogic(boolean result) throws Exception;
    }

    // 等待时间重复获取
    public <T> T executeSynchOperate(MainOperator<T> operator, String lockCacheKey, long milliTimeout) throws Exception {
        try {
            if (operator != null && lockCacheKey != null && milliTimeout >= 0L) {
                boolean locked = false;
                long startNano = System.nanoTime();
                boolean waitFlag = milliTimeout > 0L;
                long nanoTimeOut = (waitFlag ? milliTimeout : 50L) * 1000000L;
                T resultObj = null;

                try {
                    while (System.nanoTime() - startNano < nanoTimeOut) {
                        if (redisTemplate.opsForValue().setIfAbsent(lockCacheKey, LOCKED, 120L, TimeUnit.SECONDS)) {
                            locked = true;
                            break;
                        }

                        if (!waitFlag) {
                            break;
                        }

                        Thread.sleep(30L, RANDOM.nextInt(500));
                    }

                    resultObj = operator.executeInvokeLogic(locked);
                } catch (Exception ex) {
                    throw ex;
                } finally {
                    if (locked) {
                        releaseRedisLock(lockCacheKey);
                    }

                }
                return resultObj;
            } else {
                throw new Exception("参数不合法");
            }
        } catch (Exception e) {
            throw e;
        }
    }

    /**
     * @deprecated
     */
    // 不推荐使用
    @Deprecated
    public <T> T executeSynchOperate(MainOperator<T> operator, String lockCacheKey) throws Exception {
        boolean locked = false;
        T resultObj = null;

        try {
            if (redisTemplate.opsForValue().setIfAbsent(lockCacheKey, LOCKED, 120L, TimeUnit.MICROSECONDS)) {
                locked = true;
            }

            resultObj = operator.executeInvokeLogic(locked);
        } catch (Exception ex) {
            throw ex;
        } finally {
            if (locked) {
                releaseRedisLock(lockCacheKey);
            }

        }

        return resultObj;
    }


    /**
     * 释放锁
     *
     * @param cacheKey
     */
    public boolean releaseRedisLock(final String cacheKey) {
        Boolean deleteLock = redisTemplate.delete(cacheKey);
        if (Boolean.TRUE.equals(deleteLock)) {
            return true;
        }
        return false;
    }


    public static void main(String[] args) {
        /***
         * 使用测试
         */
        /**
         * 在时间范围内重复执行操作，直到成功
         * @return
         * @throws Exception
         */
        RedisLockUtilWithWaittime redisLockUtilWithWaittime = new RedisLockUtilWithWaittime();
        String localKey = "myTest_1";
        try {

            String s = redisLockUtilWithWaittime.executeSynchOperate(result -> {
                if (!result) {
                    throw new Exception("");
                }
                // 数据库逻辑
                return "ww";
            }, localKey, 5000);

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

    }
}

第三种

原文地址

https://blog.csdn.net/long2010110/article/details/82911168?spm=1001.2101.3001.6650.2&utm_medium=distribute.pc_relevant.none-task-blog-2defaultCTRLISTdefault-2-82911168-blog-123393216.pc_relevant_default&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2defaultCTRLISTdefault-2-82911168-blog-123393216.pc_relevant_default&utm_relevant_index=5


/**
 * 第三种
 */
class RedisLock {
    @Autowired
    static RedisTemplate redisTemplate;

    private static final Long SUCCESS = 1L;

    /**
     * 获取锁
     *
     * @param lockKey
     * @param value
     * @param expireTime：单位-秒
     * @return
     */
    public static boolean getLock(String lockKey, String value, 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);

            Long result = (Long) redisTemplate.execute(redisScript, Collections.singletonList(lockKey), value, expireTime);

            if (SUCCESS.equals(result)) {
                return true;
            }

        } catch (Exception e) {

        }
        return ret;
    }

    /**
     * 释放锁
     *
     * @param lockKey
     * @param value
     * @return
     */
    public static boolean releaseLock(String lockKey, String value) {

        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);

        Long result = (Long) redisTemplate.execute(redisScript, Collections.singletonList(lockKey), value);
        if (SUCCESS.equals(result)) {
            return true;
        }

        return false;
    }
}

第四种

原文地址

https://blog.csdn.net/jf991804033/article/details/109382683?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522165474058716780357210246%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=165474058716780357210246&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2blogbaidu_landing_v2~default-1-109382683-null-null.nonecase&utm_term=redistemplate+%E5%88%86%E5%B8%83%E5%BC%8F%E9%94%81&spm=1018.2226.3001.4450

class RedisLockUtils {


    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 获取锁的超时时间
     */
    private static final long timeout = 300;

    /**
     * 加锁，无阻塞
     *
     * @param key
     * @param expireTime
     * @param value      存入Redis 值   推荐使用 uuid
     * @return
     */
    public Boolean lock(String key, String value, long expireTime) {

        String requestId = value;
        Long start = System.currentTimeMillis();
        //自旋，在一定时间内获取锁，超时则返回错误
        for (; ; ) {
            //Set命令返回OK，则证明获取锁成功
            Boolean ret = redisTemplate.opsForValue().setIfAbsent(key, requestId, expireTime,
                    TimeUnit.SECONDS);
            if (ret) {
                return true;
            }
            //否则循环等待，在timeout时间内仍未获取到锁，则获取失败
            long end = System.currentTimeMillis() - start;
            if (end >= timeout) {
                return false;
            }
        }
    }


    /**
     * 删除缓存
     * *
     *
     * @param key 可以传一个值 或多个      建议与lun脚本一起使用
     */
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    public static void main(String[] args) {
        /**
         * 锁的key前缀
         */
        String lockStr = "r_lock_";

         /**
         * 获取锁最大失败次数
         */
        int maxFailCount = 5;
        RedisLockUtils  redisLockUtils =new RedisLockUtils();

        String key = "test";
        // 锁的过期时间，避免死锁，根据业务调整，毫秒
        long expireTime = 1000;
        //判断是否获得锁
        boolean lock = redisLockUtils.lock(lockStr,UUID.randomUUID().toString(),  expireTime);
        if (lock) {
            try {


                //处理业务的方法
                //TODO


            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //解锁
                redisLockUtils .del(lockStr);
            }
        } else {
            int failCount = 1;
            while (failCount <= maxFailCount) {
                //判断是否获得锁
                if ( redisLockUtils.lock(lockStr,UUID.randomUUID().toString(),  expireTime) ){
                    //处理业务的方法
                    //TODO

                    //解锁
                    redisLockUtils .del(lockStr);
                } else {
                    failCount++;
                }
            }
            throw new RuntimeException("当前创建的数量太多了，请稍后再试。");
        }
    }

}

第五种

原文地址

https://blog.csdn.net/lzq199528/article/details/103421826?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522165474165516780366537860%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=165474165516780366537860&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2blogfirst_rank_ecpm_v1~rank_v31_ecpm-10-103421826-null-null.nonecase&utm_term=redistemplate+%E5%88%86%E5%B8%83%E5%BC%8F%E9%94%81&spm=1018.2226.3001.4450

class RedisImpl {
    @Autowired
    public RedisTemplate redisTemplate;

//    @Scheduled(cron = "* * * * * ?")
//    public void test() {
//        // 模仿多服务
//        System.out.println("======================================================");
//        new Thread(() -> redisLock("线程1")).start();
//        new Thread(() -> redisLock("线程2")).start();
//        new Thread(() -> redisLock("线程3")).start();
//        new Thread(() -> redisLock("线程4")).start();
//    }


    public void redisLock(String threadName) {
        boolean bol = getLock("aa");
        if (bol) {
            try {
                // 执行业务
                System.out.println(threadName + "执行业务");
            } finally {
                unlock("aa");
            }

        } else {
            // 并发执行了
            System.out.println("有服务器正在执行此次无需再次执行");
        }

    }



    // 获得锁 ture 获得锁 false 没有获得锁
    public Boolean getLock(String key) {
        // 创建事物 防止命令执行一半
        redisTemplate.multi();
        redisTemplate.execute(
                (RedisCallback<Boolean>) conn -> {
                    try {
                        conn.setNX(redisTemplate.getStringSerializer().serialize(key),
                                redisTemplate.getStringSerializer().serialize(key));
                    } finally {
                        // 关闭释放链接
                        conn.close();
                    }
                    return null;
                });
        // 防止死锁。 10秒后删除key
        redisTemplate.expire(key, 10, TimeUnit.SECONDS);
        List<Object> list = redisTemplate.exec();
        return (Boolean) list.get(0);
    }

    // 释放锁
    private void unlock(String key) {
        redisTemplate.delete(key);
    }
}

第六种

原文地址

https://blog.csdn.net/qq_34560135/article/details/113556357?ops_request_misc=&request_id=&biz_id=102&utm_term=redistemplate%20%E5%88%86%E5%B8%83%E5%BC%8F%E9%94%81&utm_medium=distribute.pc_search_result.none-task-blog-2blogsobaiduweb~default-2-113556357.nonecase&spm=1018.2226.3001.4450

class RedisLockUtil {


    private static ThreadLocal<Thread> THREA_LOCAL = new ThreadLocal<>();
    private final String lock_prefix = "lock_prefix:";
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**  加锁
     * @param lock   锁 的key
     * @param timeoutSeconds
     * @return
     * @throws InterruptedException
     */
    public String lock(String lock, long timeoutSeconds) throws InterruptedException {

        try {
            String identification = UUID.randomUUID().toString();
            String lockName = String.format("%s%s", lock_prefix, lock);

            Boolean flag = redisTemplate.opsForValue().setIfAbsent(lockName, identification, timeoutSeconds, TimeUnit.SECONDS);
            if (flag) {
                // 续签
                Thread renewal = new Thread(new RenewalLock(lock, identification, timeoutSeconds));
                renewal.setDaemon(true);
                THREA_LOCAL.set(renewal);
                renewal.start();
                return identification;
            }
        } finally {
            //  加锁失败处理

        }

        return "";
    }

    /** 释放锁
     * @param lock
     * @param identification
     */
    public void release(String lock, String identification) {
        try {
            redisTemplate.setEnableTransactionSupport(true);
            String lockName = String.format("%s%s", lock_prefix, lock);
            redisTemplate.watch(lockName);
            String identificationDB = redisTemplate.opsForValue().get(lockName);
            if (identificationDB != null && identification != null && identification.equals(identificationDB)) {
                redisTemplate.multi();
                redisTemplate.delete(lockName);
                redisTemplate.exec();
            }
            redisTemplate.unwatch();
        } finally {
            RedisConnectionUtils.unbindConnection(redisTemplate.getConnectionFactory());
            THREA_LOCAL.get().interrupt();
            THREA_LOCAL.remove();
        }
    }

    /**
     * 续签lock
     */
    private class RenewalLock implements Runnable {

        private String lockName;
        private String identification;
        private Long timeout;

        public RenewalLock(String lock, String identification, Long timeout) {
            this.lockName = lock_prefix + lock;
            this.identification = identification;
            this.timeout = timeout;
        }

        @Override
        public void run() {
            int i = 0;
            while (true) {
                try {
                    if (Thread.currentThread().isInterrupted()) {
                        return;
                    }
                    TimeUnit.SECONDS.sleep(timeout / 2);
                    redisTemplate.setEnableTransactionSupport(true);
                    redisTemplate.watch(lockName);
                    String identificationDB = redisTemplate.opsForValue().get(lockName);
                    if (identificationDB != null && identification != null && identificationDB.equals(identification)) {
                        redisTemplate.multi();
                        redisTemplate.expire(lockName, timeout, TimeUnit.SECONDS);
                        redisTemplate.exec();
                    }
                    redisTemplate.unwatch();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } catch (Exception e) {
                    Thread.currentThread().interrupt();

                } finally {
                    RedisConnectionUtils.unbindConnection(redisTemplate.getConnectionFactory());
                }
            }
        }
    }

}
妃宫千早
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Redis搭配RedisTemplate实现分布式锁实战实例
m0_46652188的博客
04-26 1989
研究加锁的初衷是：监听redis过期消息提醒，同一个数据（键）过期会有多次通知提醒。原因是：可能是由于 Redis 的主从复制或者分片集群等机制导致的。在主从复制或者分片集群中，可能会发生多个节点同时订阅了相同的键空间通知，从而导致同一个键空间事件被多次触发。 我的解决方法是：给键过期后提醒的回调函数加锁，收到多个通知提醒，回调函数加锁后最终只会有一个执行，其他没有获得锁的回调不会执行，这样就避免了重复执行任务代码。
redis RedisTemplate实现分布式锁
guohao_Kwok的博客
04-06 1766
面试：你懂什么是分布式系统吗？Redis分布式锁都不会？>>> ...
springboot集成redis 分布式锁(redistemplate,lua,redisson)
jun2571的博客
04-26 3170
springboot集成redis 分布式锁(redistemplate,lua,redisson)
分布式锁--redis实现
最新发布
m0_64116616的博客
05-14 737
基于redis实现分布式锁
Redis实现分布式锁
weixin_45570824的博客
01-18 1833
Redis实现分布式锁
redistemplate分布式锁实现_Redis实现分布式文件夹锁
weixin_39656686的博客
12-08 313
缘起最近做一个项目，类似某度云盘，另外附加定制功能，本人负责云盘相关功能实现，这个项目跟云盘不同的是，以项目为分配权限的单位，同一个项目及子目录所有有权限的用户可以同时操作所有文件，这样就很容易出现并发操作，而且表结构设计的时候，定下来文件和文件夹都有个path字段，存储的是所在父级文件夹路径，这样检索方便，重命名和移动比较麻烦。如下，例如甲同学正在移动项目下C文件夹，而此时乙同学也在操作项目下D...
RedisTemplate实现分布式锁
mengkey1990的博客
04-19 1688
@Component public class RedisDistributedLockUtils { private static final String NX = "NX"; private static final String EX = "EX"; private static final String LOCK_OK = "OK"; private sta...
redisTemplate封装成redisUtils和分布式锁实现
06-18
本篇将深入探讨如何将RedisTemplate封装成RedisUtils工具类，并实现分布式锁功能。 首先，我们需要引入Spring Data Redis的依赖库，这通常在项目的pom.xml或build.gradle文件中完成。添加对应版本的Redis连接器和...
springboot redis分布式锁代码实例
08-25
"SpringBoot Redis分布式锁代码实例" SpringBoot Redis分布式锁代码实例是指通过SpringBoot框架和Redis数据库来实现分布式锁的机制。分布式锁是指在分布式系统中，多个节点或进程需要访问共享资源时，为了避免冲突...
Redis分布式锁.zip
10-13
**Redis分布式锁的原理** 分布式锁通常需要满足以下条件： 1. **互斥性**：在同一时刻，只能有一个客户端获取锁。 2. **可重入性**：持有锁的客户端可以再次获取该锁，防止死锁。 3. **自动续期**：防止锁过期导致...
Redis分布式锁代码示例
03-28
接下来，我们将探讨如何在SpringBoot项目中集成Redis，并创建分布式锁的实现。SpringBoot提供了`spring-boot-starter-data-redis`依赖，可以方便地与Redis进行交互。首先，在`pom.xml`文件中添加依赖： ```xml ...
SpringBoot 使用 Redis 分布式锁解决并发问题.docx
04-25
在SpringBoot应用中集成Redis分布式锁，可以创建一个`RedisLock`工具类，包含加锁和解锁的方法。加锁操作需要确保原子性，即同时设置键和过期时间，这在SpringBoot 2.x版本以上可以通过`opsForValue().setIfAbsent()...
redis 高并发分布式锁实现
wjavadog的博客
11-24 1322
一般在单体应用中，如果遇到高并发可以通过 synchronized 或者 Lock 进行加锁，但是现在大部分应用都是采用分布式的方式进行部署，这样像 synchronized 和 Lock 这样的锁就不适用了。 这个使用我们可以使用分布式锁来实现，分布式锁的实现方式主要有： 基于数据库的分布式锁 基于缓存的分布式锁 基于 Zookeeper 的分布式锁 本次主要记录一下如果是用 redis 实...
Redis分布式锁注解（Java实现）
weixin_47224121的博客
06-07 1846
在项目中遇到了插入重复数据的问题，为了防止并发造成重复数据的插入，故使用加锁，而传统的加锁是单机锁并不适用分布式项目，故采用Redis分布式锁。
redisTemplate分布式锁演变、redission分布式锁实现
2301_79963818的博客
04-04 829
我还为大家准备了一套体系化的架构师学习资料包以及BAT面试资料，供大家参考及学习已经将知识体系整理好（源码，笔记，PPT，学习视频）《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！[外链图片转存中…(img-xTexhQsX-1712185386775)][外链图片转存中…(img-14Z7NsIM-1712185386775)][外链图片转存中…(img-2vnEVTHx-1712185386775)]
Redis分布式锁的实现
weixin_57128596的博客
09-16 2600
1）加锁和解锁都用Lua脚本，脚本中判断各种可能的逻辑（有过期时间的设置，判断是不是自己的锁，是否是重入等），也保证了判断和加锁的原子性 解决上面讲的问题一二三四。总结：所谓的分布式锁，就是用一个第三方的数据库，所有线程（包括同一个进程中的和不同进程中的）都访问的是这个数据库（这对于所有线程就是唯一的），使用逻辑锁就可以使各个线程之间不会出现并发问题。解锁用 redisTemplate.opsForValue().delete("lock");
RedisTemplate实现Redis锁
才这么点的博客
10-15 5005
Redis锁 项目中使用redis锁主要是依据 redis setnx命令的特性(SETNX:在指定的 key 不存在时，为 key 设置指定的值。 设置成功，返回 1 设置失败，返回 0 ) 实现Redis锁方式 实现Redis锁方式有很多比如:1.采用lua脚本方式,项目中采用执行lua脚本的方式获取锁跟释放锁2.整合jedis执行 SETNX 3.整合redistemplate 执行SETNX这几种方法都可已实现redis锁 Redis锁代码 @SpringBootTest class Redisl
java中用RedisTemplate实现redis加写锁
03-28
在Java中使用RedisTemplate实现Redis加写锁的步骤如下： 1. 创建RedisTemplate对象 RedisTemplate是Spring Data Redis提供的一个基于Jedis的Redis客户端。首先需要创建一个RedisTemplate对象，用于连接Redis服务器。可以使用以下代码创建一个RedisTemplate对象： ``` @Autowired private RedisTemplate<String, Object> redisTemplate; ``` 2. 获取锁 获取锁的过程可以采用Redis的setnx命令，该命令可以保证在多线程情况下只有一个线程能够获取到锁。如果当前锁已经被其他线程占用，则当前线程会等待一段时间后再次尝试获取锁，直到成功为止。可以使用以下代码实现锁的获取： ``` public boolean lock(String key, String value, long expireTime) { boolean result = redisTemplate.opsForValue().setIfAbsent(key, value); if (result) { redisTemplate.expire(key, expireTime, TimeUnit.SECONDS); } return result; } ``` 其中，key表示锁的名称，value表示锁的值，expireTime表示锁的过期时间。 3. 释放锁 释放锁的过程可以采用Redis的del命令，该命令可以将锁从Redis中删除。可以使用以下代码实现锁的释放： ``` public void unlock(String key, String value) { Object currentValue = redisTemplate.opsForValue().get(key); if (currentValue != null && currentValue.equals(value)) { redisTemplate.delete(key); } } ``` 其中，key表示锁的名称，value表示锁的值。 完整代码如下： ``` @Component public class RedisLock { @Autowired private RedisTemplate<String, Object> redisTemplate; public boolean lock(String key, String value, long expireTime) { boolean result = redisTemplate.opsForValue().setIfAbsent(key, value); if (result) { redisTemplate.expire(key, expireTime, TimeUnit.SECONDS); } return result; } public void unlock(String key, String value) { Object currentValue = redisTemplate.opsForValue().get(key); if (currentValue != null && currentValue.equals(value)) { redisTemplate.delete(key); } } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值