Redis实现分布式锁最全讲解

最新推荐文章于 2024-05-29 22:53:56 发布

knowledge are power

最新推荐文章于 2024-05-29 22:53:56 发布

阅读量227

点赞数

本文链接：https://blog.csdn.net/weixin_44971379/article/details/105340978

版权

在分布式架构中，为了实现一些业务，如控制产品超卖，我们需要某段代码是一个线程一个线程依次执行，这个时候单体架构下的synchronized 由于只在一个jvm中有效，这个时候就可以用到redis分布式锁来实现

首先实现一段库存扣减的代码：

package com.qingnian.spring.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class InventoryDeduction {

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    @RequestMapping("/reduce")
    @ResponseBody
    public String reduceDeduction(){
        //从redis内存中取出库存的总数
        int totalDeduction =Integer.valueOf(redisTemplate.opsForValue().get("totalDeduction"));
        if(totalDeduction>0){
            //库存存在，进行扣减操作
            totalDeduction-=1;
            System.out.println("扣减操作成功，剩余库存为===>"+totalDeduction);
            redisTemplate.opsForValue().set("totalDeduction", totalDeduction+"");
        }else{
            System.out.println("扣减操作失败");
        }
        return totalDeduction+"";
    }
}

redis 分布式锁实现库存扣减

@Controller
public class InventoryDeduction {

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    @RequestMapping("/reduce")
    @ResponseBody
    public String reduceDeduction(){
        //redis锁
        /*此处利用redis单线程的特性，利用setNx()方法实现：如果多线程同时到达，只能有一个线程执行，
        如果key值存在，就等待，key值不存在，就设置对应的value，方法的返回类型是一个boolean值，true
        表示获得锁成功，false表示获取锁失败*/
        Boolean ifAbsent = redisTemplate.opsForValue().setIfAbsent("key", "value");
        if (!ifAbsent) {
            //获取锁失败
            return "请稍后重试";
        }
        int totalDeduction;
        //将业务执行部分放入try catch finall 语句中，如果出现异常，则在finall 释放掉当前锁，避免阻塞
        try {
            //从redis内存中取出库存的总数
            totalDeduction = Integer.valueOf(redisTemplate.opsForValue().get("totalDeduction"));
            if(totalDeduction>0){
                //库存存在，进行扣减操作
                totalDeduction-=1;
                System.out.println("扣减操作成功，剩余库存为===>"+totalDeduction);
                redisTemplate.opsForValue().set("totalDeduction", totalDeduction+"");
            }else{
                System.out.println("扣减操作失败");
            }
        } finally {
            redisTemplate.delete("key");
        }
        return totalDeduction+"";
    }
}

上方解决方案中有一个问题：如果执行业务过程中出了问题，非抛异常，当前线程的锁也会无法释放

解决方案：为锁设置过期时间，时间到了，锁自定失效

@Controller
public class InventoryDeduction {

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    @RequestMapping("/reduce")
    @ResponseBody
    public String reduceDeduction(){
        //redis锁
        /*此处利用redis单线程的特性，利用setNx()方法实现：如果多线程同时到达，只能有一个线程执行，
        如果key值存在，就等待，key值不存在，就设置对应的value，方法的返回类型是一个boolean值，true
        表示获得锁成功，false表示获取锁失败*/
        String lockKey="key";
        Boolean ifAbsent = redisTemplate.opsForValue().setIfAbsent(lockKey, "value");
        //设置锁的过期时间，时间一到，锁自动失效，下一个线程可获得锁
        redisTemplate.expire(lockKey,30, TimeUnit.SECONDS);
        if (!ifAbsent) {
            //获取锁失败
            return "请稍后重试";
        }
        int totalDeduction;
        //将业务执行部分放入try catch finall 语句中，如果出现异常，则在finall 释放掉当前锁，避免阻塞
        try {
            //从redis内存中取出库存的总数
            totalDeduction = Integer.valueOf(redisTemplate.opsForValue().get("totalDeduction"));
            if(totalDeduction>0){
                //库存存在，进行扣减操作
                totalDeduction-=1;
                System.out.println("扣减操作成功，剩余库存为===>"+totalDeduction);
                redisTemplate.opsForValue().set("totalDeduction", totalDeduction+"");
            }else{
                System.out.println("扣减操作失败");
            }
        } finally {
            redisTemplate.delete("key");
        }
        return totalDeduction+"";
    }
}

上方解决方案中有一个问题：在锁的有限时间，跟业务的执行时间作用下，可能会出现一个情况，当前线程在finnally 语句块中释放锁的时候，第一个redis锁已经过期，而第二个线程刚好拿到锁，造成第一个线程释放掉了第二个线程的锁，造成死锁状态

解决方案：为锁设置不同的 value 值。释放锁的时候，验证 value，相同则进行释放

public class InventoryDeduction {

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    @RequestMapping("/reduce")
    @ResponseBody
    public String reduceDeduction(){
        //redis锁
        /*此处利用redis单线程的特性，利用setNx()方法实现：如果多线程同时到达，只能有一个线程执行，
        如果key值存在，就等待，key值不存在，就设置对应的value，方法的返回类型是一个boolean值，true
        表示获得锁成功，false表示获取锁失败*/
        String lockKey="key";
        String lockValue= UUID.randomUUID().toString();
        Boolean ifAbsent = redisTemplate.opsForValue().setIfAbsent(lockKey, lockValue);
        //设置锁的过期时间，时间一到，锁自动失效，下一个线程可获得锁
        redisTemplate.expire(lockKey,30, TimeUnit.SECONDS);
        if (!ifAbsent) {
            //获取锁失败
            return "请稍后重试";
        }
        int totalDeduction;
        //将业务执行部分放入try catch finall 语句中，如果出现异常，则在finall 释放掉当前锁，避免阻塞
        try {
            //从redis内存中取出库存的总数
            totalDeduction = Integer.valueOf(redisTemplate.opsForValue().get("totalDeduction"));
            if(totalDeduction>0){
                //库存存在，进行扣减操作
                totalDeduction-=1;
                System.out.println("扣减操作成功，剩余库存为===>"+totalDeduction);
                redisTemplate.opsForValue().set("totalDeduction", totalDeduction+"");
            }else{
                System.out.println("扣减操作失败");
            }
        } finally {
            //比较value值，如果相等，表示为同一线程，进行锁的释放
            if(lockValue==(String) redisTemplate.opsForValue().get(lockKey)){
                redisTemplate.delete("key");
            }
        }
        return totalDeduction+"";
    }
}

上方解决方案中有一个问题：锁的设置key值，锁的有限时间设定为两步操作，不具备原子性

解决方案：将key值，与有效时间合并为一步

@Controller
public class InventoryDeduction {

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    @RequestMapping("/reduce")
    @ResponseBody
    public String reduceDeduction(){
        String lockKey="key";
        String lockValue= UUID.randomUUID().toString();
        //此两步合并，保证原子性
        /*Boolean ifAbsent = redisTemplate.opsForValue().setIfAbsent(lockKey, lockValue);
        //设置锁的过期时间，时间一到，锁自动失效，下一个线程可获得锁
        redisTemplate.expire(lockKey,30, TimeUnit.SECONDS);*/
        Boolean ifAbsent = redisTemplate.opsForValue().setIfAbsent(lockKey, lockValue,30, TimeUnit.SECONDS);
        if (!ifAbsent) {
            //获取锁失败
            return "请稍后重试";
        }
        int totalDeduction;
        //将业务执行部分放入try catch finall 语句中，如果出现异常，则在finall 释放掉当前锁，避免阻塞
        try {
            //从redis内存中取出库存的总数
            totalDeduction = Integer.valueOf(redisTemplate.opsForValue().get("totalDeduction"));
            if(totalDeduction>0){
                //库存存在，进行扣减操作
                totalDeduction-=1;
                System.out.println("扣减操作成功，剩余库存为===>"+totalDeduction);
                redisTemplate.opsForValue().set("totalDeduction", totalDeduction+"");
            }else{
                System.out.println("扣减操作失败");
            }
        } finally {
            //比较value值，如果相等，表示为同一线程，进行锁的释放
            if(lockValue==(String) redisTemplate.opsForValue().get(lockKey)){
                redisTemplate.delete("key");
            }
        }
        return totalDeduction+"";
    }
}

redis 锁这样实现就可以了，如果考虑安全性，这个版本还有一点：第一个线程执行过程中，锁的过期时间到了，多个线程同时执行业务部分，可能会出错

解决方案：使用redisson 实现分布式锁，原理大概为：在第一个线程拿到锁的同时，开启一个守护线程，不停的定时去延长锁的有效时长，直到这把锁释放

代码部分：
1：pom 引入 redisson 依赖

<dependency>
     <groupId>org.redisson</groupId>
     <artifactId>redisson</artifactId>
     <version>3.6.5</version>
</dependency>

2：生成redisson 对象

@SpringBootApplication
@MapperScan(basePackages = "com.qingnian.spring.dao")
public class SpringbootRedisApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootRedisApplication.class, args);
    }

    @Bean
    public Redisson getRedisson(){
        Config config = new Config();
        //单机模式
        config.useSingleServer().setAddress("redis://127.0.0.1:6379").setDatabase(0);
        return (Redisson) Redisson.create(config);
    }
}

3：代码部分

@Controller
public class InventoryDeduction {

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    @Autowired
    private Redisson redisson;

    @RequestMapping("/reduce")
    @ResponseBody
    public String reduceDeduction(){
        String lockKey="key";
        int totalDeduction;
        //redisson 实现锁
        RLock lock = redisson.getLock(lockKey);
        //将业务执行部分放入try catch finall 语句中，如果出现异常，则在finall 释放掉当前锁，避免阻塞
        try {
            lock.tryLock();
            //从redis内存中取出库存的总数
            totalDeduction = Integer.valueOf(redisTemplate.opsForValue().get("totalDeduction"));
            if(totalDeduction>0){
                //库存存在，进行扣减操作
                totalDeduction-=1;
                System.out.println("扣减操作成功，剩余库存为===>"+totalDeduction);
                redisTemplate.opsForValue().set("totalDeduction", totalDeduction+"");
            }else{
                System.out.println("扣减操作失败");
            }
        } finally {
            lock.unlock();
        }
        return totalDeduction+"";
    }
}

knowledge are power

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Redis实现分布式锁最全讲解

在分布式架构中，为了实现一些业务，如控制产品超卖，我们需要某段代码是一个线程一个线程依次执行，这个时候单体架构下的synchronized 由于只在一个jvm中有效，这个时候就可以用到redis分布式锁来实现首先实现一段库存扣减的代码：package com.qingnian.spring.controller;import org.springframework.beans.factor...
复制链接

扫一扫