rediSsion 分布式锁使用

最新推荐文章于 2024-05-18 18:02:24 发布
最新推荐文章于 2024-05-18 18:02:24 发布
阅读量866 收藏 2
点赞数
分类专栏： java 文章标签： java redisson jedis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53135442/article/details/113602564
版权

rediSsion 分布式锁使用

1场景设定

假定两个不同服务去请求消耗剩余商品库存数（100）
商品库存为100，数目模拟存在redis中。key值number，value100

2存值

存入方式选StringRedisTemplate存储或者jedis存储。

1 StringRedisTemplate存储

引入相关pom文件
  <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.3.4.RELEASE</version>
        </dependency>
         <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>${redisson.version}</version>
        </dependency>
配置yml
spring:
  application:
    name: User
  redis:
    database: 7
    host: *******
    jedis:
      pool:
        max-active: 100
        max-idle: 20
        max-wait: -1ms
    password: *******
    port: 6379
    timeout: 20
    redisjedis:
      pool:
        min-idle: 0
@Autowired注入使用
 @Autowired
    private StringRedisTemplate stringRedisTemplate;//自带的字符串模板类，用于存储字符串

 stringRedisTemplate.opsForValue().set("number","100");

2 jedis存储（使用jedispool）

引入相关pom文件
 <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>${jedis.version}</version>
        </dependency>

        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>${redisson.version}</version>
        </dependency>
配置yml（同上）
添加配置类
/**
 * zbeing
 */
@Configuration
public class RedisUtil {
    private static  Integer maxToal;
    private static  String host;
    private static Integer prot;
    private static Integer timeout;
    private static String password;
    @Value("${spring.redis.jedis.pool.max-active}")
    public  void setMaxToal(Integer maxToal) {
        RedisUtil.maxToal = maxToal;
    }
    @Value("${spring.redis.host}")
    public  void setHost(String host) {
        RedisUtil.host = host;
    }
    @Value("${spring.redis.port}")
    public  void setProt(Integer prot) {
        RedisUtil.prot = prot;
    }
    @Value("${spring.redis.timeout}")
    public  void setTimeout(Integer timeout) {
        RedisUtil.timeout = timeout;
    }
    @Value("${spring.redis.password}")
    public  void setPassword(String password) {
        RedisUtil.password = password;
    }
    public static void saveRedis(String key, String value) {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(maxToal);
        JedisPool pool = new JedisPool(jedisPoolConfig, host, prot,timeout,password,7);
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            jedis.set(key, value);
            System.out.println("已存入的redis值" + jedis.get(key));
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //还回pool中
            if (jedis != null) {
                jedis.close();
            }
        }
        pool.close();
    }

}

注：因为JedisPoolpool的util是工具类（静态），所以交由spring管理时，静态属性赋值要采用上述set属性时进行赋值
在这里插入图片描述

使用
 RedisUtil.saveRedis("number","100");

3 redisson

1redisson 配置类

/**
 * zbeing
 */
@Configuration
public class RedissonConfig {

    @Value("${spring.redis.database}")
    private int database;
    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private String port;
    @Value("${spring.redis.password}")
    private String password;
    @Value("${spring.redis.timeout}")
    private int timeout;

    /**
     * RedissonClient,单机模式
     *
     * @return
     * @throws IOException
     */
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson() {
        Config config = new Config();
        SingleServerConfig singleServerConfig = config.useSingleServer();
        singleServerConfig.setAddress("redis://" + host + ":" + port);
        singleServerConfig.setTimeout(timeout);
        singleServerConfig.setDatabase(database);
        System.out.println("获取"+JSON.toJSONString(singleServerConfig));
        if (password != null && !"".equals(password)) { //有密码
            singleServerConfig.setPassword(password);
        }
        return Redisson.create(config);
    }
    }

2redisson使用

  static final String KEY = "LOCK_KEY";
@Autowired
    private RedissonClient redissonClient;
    @GetMapping("/test")
    public Object test(){
        for (int i = 0; i <100 ; i++) {
            new Thread(()->{
                redissonClient.getLock(KEY).lock();
                //LockUtil.lock(KEY);
                try {
                    String number = stringRedisTemplate.opsForValue().get("number");
                    int num = Integer.parseInt(number);
                    System.out.println("获取的数目"+num);
                    Thread.sleep(1000);
                    if(num>0&&num<=100){
                        System.out.println(" 处理业务。。。");
                        stringRedisTemplate.opsForValue().set("number",String.valueOf(num- 1));
                    }
                } catch (Exception e) {
                    //异常处理
                }finally{
                    //释放锁
                  //  LockUtil.unlock(KEY);
                    redissonClient.getLock(KEY).unlock();
                }
            }
            ).start();
        }
        //加锁
        return "SUCCESS";
    }

3演示

存入redis值
在这里插入图片描述
进行不同服务调用
在这里插入图片描述
在这里插入图片描述
得到结果
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4 redisson优化

package com.demo.p.util;

import java.util.concurrent.TimeUnit;

public interface Locker {
    /**
     * 获取锁，如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。
     *
     * @param lockKey
     */
    void lock(String lockKey);

    /**
     * 释放锁
     *
     * @param lockKey
     */
    void unlock(String lockKey);

    /**
     * 获取锁,如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。如果获取到锁后，执行结束后解锁或达到超时时间后会自动释放锁
     *
     * @param lockKey
     * @param timeout
     */
    void lock(String lockKey, int timeout);

    /**
     * 获取锁,如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。如果获取到锁后，执行结束后解锁或达到超时时间后会自动释放锁
     *
     * @param lockKey
     * @param unit
     * @param timeout
     */
    void lock(String lockKey, TimeUnit unit, int timeout);

    /**
     * 尝试获取锁，获取到立即返回true,未获取到立即返回false
     *
     * @param lockKey
     * @return
     */
    boolean tryLock(String lockKey);

    /**
     * 尝试获取锁，在等待时间内获取到锁则返回true,否则返回false,如果获取到锁，则要么执行完后程序释放锁，
     * 要么在给定的超时时间leaseTime后释放锁
     *
     * @param lockKey
     * @param waitTime
     * @param leaseTime
     * @param unit
     * @return
     */
    boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit)
            throws InterruptedException;

    /**
     * 锁是否被任意一个线程锁持有
     *
     * @param lockKey
     * @return
     */
    boolean isLocked(String lockKey);

}


package com.demo.p.util;

import java.util.concurrent.TimeUnit;

public class LockUtil {
    private static Locker locker;

    /**
     * 设置工具类使用的locker
     *
     * @param locker
     */
    public static void setLocker(Locker locker) {
        LockUtil.locker = locker;
    }

    /**
     * 获取锁
     *
     * @param lockKey
     */
    public static void lock(String lockKey) {
        locker.lock(lockKey);
    }

    /**
     * 释放锁
     *
     * @param lockKey
     */
    public static void unlock(String lockKey) {
        locker.unlock(lockKey);
    }

    /**
     * 获取锁，超时释放
     *
     * @param lockKey
     * @param timeout
     */
    public static void lock(String lockKey, int timeout) {
        locker.lock(lockKey, timeout);
    }

    /**
     * 获取锁，超时释放，指定时间单位
     *
     * @param lockKey
     * @param unit
     * @param timeout
     */
    public static void lock(String lockKey, TimeUnit unit, int timeout) {
        locker.lock(lockKey, unit, timeout);
    }

    /**
     * 尝试获取锁，获取到立即返回true,获取失败立即返回false
     *
     * @param lockKey
     * @return
     */
    public static boolean tryLock(String lockKey) {
        return locker.tryLock(lockKey);
    }

    /**
     * 尝试获取锁，在给定的waitTime时间内尝试，获取到返回true,获取失败返回false,获取到后再给定的leaseTime时间超时释放
     *
     * @param lockKey
     * @param waitTime
     * @param leaseTime
     * @param unit
     * @return
     * @throws InterruptedException
     */
    public static boolean tryLock(String lockKey, long waitTime, long leaseTime,
                                  TimeUnit unit) throws InterruptedException {
        return locker.tryLock(lockKey, waitTime, leaseTime, unit);
    }

    /**
     * 锁释放被任意一个线程持有
     *
     * @param lockKey
     * @return
     */
    public static boolean isLocked(String lockKey) {
        return locker.isLocked(lockKey);
    }

}


 @GetMapping("/test")
    public Object test(){
        for (int i = 0; i <100 ; i++) {
            new Thread(()->{
                //redissonClient.getLock(KEY).lock();
                LockUtil.lock(KEY);
                try {
                    String number = stringRedisTemplate.opsForValue().get("number");
                    int num = Integer.parseInt(number);
                    System.out.println("获取的数目"+num);
                    Thread.sleep(1000);
                    if(num>0&&num<=100){
                        System.out.println(" 处理业务。。。");
                        stringRedisTemplate.opsForValue().set("number",String.valueOf(num- 1));
                    }
                } catch (Exception e) {
                    //异常处理
                }finally{
                    //释放锁
                    LockUtil.unlock(KEY);
                   // redissonClient.getLock(KEY).unlock();
                }
            }
            ).start();
        }
        //加锁
        return "SUCCESS";
    }
有心的敢敢l
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redission分布式锁工具类
07-18
redission分布式锁工具类，在分布式系统中需要加锁可以直接使用
redis/redission实现分布式锁
The_xiaoke的博客
09-06 4219
redis/redission实现分布式锁
【LUA】如何借助redis的lua功能实现库存扣减
qq_43783527的博客
09-15 2081
强调：当你打算在本地测试redis的某个功能的时候，你必须保证你本地的springboot版本、redis版本（两个：pom中引入的依赖版本，本地redis-ser的版本）和你公司项目中的版本保持一致。因为不同版本，差别挺大的，往往。建议使用StringRedisTemplate来执行lua脚本，好处是我不需要考虑我的redis客户端到底是使用jedis还是lettuce（换言之，我不需要考虑springboot的版本）。--不推荐，因为大部分公司使用的是2.x以上的版本了，不能因为你这个需要降低版本。
Redission实现分布式锁
最新发布
m0_64116616的博客
05-18 1413
redission实现分布式锁，根据底层源码，分析重入锁原理，锁重试机制和锁续约（WatchDog机制）
Redis 高并发分布式锁学习总结
weixin_45161367的博客
08-27 338
Redis 高并发分布式锁学习总结
[分布式锁] Springboot整合Redisson实现超卖问题还原和分析
GSON的博客
10-19 1928
超卖简单代码 写一段简单正常的超卖逻辑代码，多个用户同时操作同一段数据，探究出现的问题。 Redis中存储一项数据信息，请求对应接口，获取商品数量信息； 商品数量信息如果大于0，则扣减1，重新存储Redis中； 运行代码测试问题。 /** * Redis数据库操作，超卖问题模拟 * @author * */ @RestController public class RedisController { // 引入String类型redis操作模板 @Autowired priva
Redis 如何实现库存扣减操作和防止被超卖
热门推荐
吴名氏的博客
02-27 12万+
Redis 如何实现库存扣减操作和防止被超卖
Java注解如何基于Redission实现分布式锁
08-25
本文介绍了如何使用Java注解基于Redission实现分布式锁，我们可以使用`DistributedLock`注解来标注需要分布式锁的方法，然后使用AOP机制来拦截这些方法，并使用Redission客户端来获取分布式锁。这种方式可以方便地...
记录redisson实现redis分布式事务锁
04-24
在使用Redisson实现分布式锁时，我们需要创建一个RedissonClient实例，这通常在Spring Boot应用中通过配置类来完成。首先，在`application.yml`或`application.properties`中配置Redis连接信息，例如： ```yaml ...
springboot 集成Redission 简单完美解决分布式锁
06-03
4. **使用分布式锁**：现在可以在业务代码中注入RedissonClient，使用它提供的锁功能。例如，创建一个全局唯一的锁： ```java @Autowired private RedissonClient redisson; public void doSomethingCritical() { ...
Redission分布式锁-本地单机Redis实战-springboot-redis-lock.zip
01-31
本项目“Redission分布式锁-本地单机Redis实战-springboot-redis-lock”旨在教你如何在SpringBoot项目中集成Redisson库，实现基于Redis的分布式锁功能。下面我们将深入探讨相关的知识点。 1. **Redisson**：...
redis实现分布式锁,消息队列
qq_55272229的博客
12-25 1104
目录当电商项目中出现秒杀功能,同一时间多个线程发起请求,如何保证多个线程的安全呢,这就是分布式锁需要实现的功能,分布式锁一个较为完美的框架就不得不提redission了。
六、redis分布式锁-解决超卖问题
XZQ_STUD的博客
12-17 291
package com.gaia.test.redisTest.distributelock; import com.gaia.test.redisTest.util.JedisPoolInstance; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import java.util.UUID; /** * Description: * * @author xuzhiqiang * Date 20
redis分布式锁和简单秒杀限流的实现
csdncjh的博客
05-23 1155
分布式锁 看门狗防止死锁 redission实现 依赖 <!--整合redission框架start--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> &...
扣减库存，redis你值得拥有
shrek的博客
11-30 976
扯扯犊子 并发知识点总结： 1.秒杀，物理业务隔离，抽成单独的服务器 2.接口设计，防止洪流访问数据库。 3.加redis缓存。 4.缓存雪崩，一个请求，多个key同时失效，避免同时失效。多个请求，一个key失效。加锁 5.热点数据，缓存预热。 6.超过10w+的时候，增加本地缓存ehchache，redis作为二级缓存 7.缓存，ehcache,现在有了大堆得概念，毕竟是本地缓存，减少io，加快速度 扣减库存逻辑，你值得拥有~ 1.基于DB做数据库的扣减库存 2.基于redis扣减库存 incr.
基于redis实现扣减库存的优化
tao_1996的博客
06-22 499
今天分享一个在项目上做的关于领取券码操作的优化，是基于redis实现的，提高接口的并发量。 背景 用户通过券码编号领取券码，领取成功则返回对应的券号，表结构是一个coupon表存储券码，有个coupon_stock库存表关联coupon表。 用户领取的时候，需要在coupon_stock取一条“未发放”状态记录并修改为“已发放”状态(扣减库存)，返回该条记录的券号即可。 优化前实现逻辑 用zookeeper做一个分布式锁，用户领取时抢锁，抢到锁后查询coupon_stock是否还有未发放的记录，有则
认识分布式锁、使用分布式锁 Redission、实现秒杀案例
qq_54429571的博客
12-09 1074
认识分布式锁的基本原理、实现方式；分布式锁 Redisson 功能介绍、快速入门；利用Redisson 实现秒杀案例。
高并发，减库存，防超卖，redis redisson分布式锁
weixin_43504955的博客
09-29 853
redis锁，超卖问题
基于Redis（SETNX）实现分布式锁，案例：解决高并发下的订单超卖，秒杀
emgexgb_sef的博客
07-31 551
因为设置每个锁的key都会带有一个失效的时间这么做的目的就是因为怕业务代码出了问题报错了没有执行删除锁导致锁阻塞所以我们可以先给这个锁加一个失效的时间这样就算业务代码不删除锁它自己也会释放但是存在的问题就是如果的业务代码指定的时间超过了锁的失效时间导致你业务没执行完锁已经释放了这时候其他的线程就会获取到这个锁这时候你这个业务执行完了执行了删除锁但是你删除的是线程2的锁所以这时候锁又被释放了这种恶性的循环。线程2也获取到了和线程1相同的数量的商品。...
redission分布式锁使用
08-19
Redission是一个基于Redis的分布式锁框架，它提供了简单易用的API来实现分布式锁。下面是一个简单的示例，演示了如何...以上是一个简单的Redission分布式锁使用示例，你可以根据自己的实际需求进行相应的调整和扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值