Spring Boot学习总结（19）——使用Redisson实现分布式锁

ゝ一纸荒年。 2023-06-18 14:54 1阅读 0赞

# 一、什么是分布式？ #

要想说什么是分布式，那么首先要知道分布式之前的系统是什么样的架构，之前的架构又存在什么样的问题？

### 单体架构  ###

分布式之前就是单体架构，单体架构顾名思义就是将所有的业务功能打包在一个应用中，然后部署在服务器上。如果我们把单体架构比作一个汽车工厂，那么从汽车发动机到汽车上的一个螺丝钉都需要由它来负责完成，如果有一天这家工厂由于自然灾害的原因导致业务量急剧下滑，甚至停止生产，那么这个整个工厂无论是造发动机的，还是造螺丝钉的全部都得停工。落实到互联网就是单体架构开发成本高、出现故障影响的范围大，很难适应现在的互联网项目。

### 分布式  ###

既然单体架构不足以解决现在存在的高并发、高性能、高可用的要求，那么分布式就来了，原来我们把一个汽车所有的零件都放在一家工厂进行生产，结果会出现上面停工的情况，那么分布式怎么解决的？所谓分布式就是把所有的零件分开生产，每个工厂根据自己的特长来生产相应的汽车配件，最后统一组装，即使因为一些其他原因，导致某个工厂停止了生产，但是依旧不影响其他工厂的生产进度，我们可以通过小的代价来寻找其他工厂来代替停工的工厂，确保我们的生产任务可以正常的运转。

# 二、为什么要有分布式锁？ #

### 如果没有分布式锁  ###

解释这个问题之前，我们先来说下，如果没有分布式锁会存在什么问题，举个经典的例子，如果我们有一个购物网站，有一件商品只有10件可卖，此时用户A进来后还有1个库存，然后用户A下单付款，扣减库存，在用户A付款的这个过程中，恰好用户B进来了，也看到还有一个库存，用户B也开始下单付款，扣减库存，那么这个过程很明显已经出了问题，出现了超卖的问题。

### 分布式锁  ###

如果有了分布式锁就不会出现超卖问题，举个简单的例子，分布式就像是银行的ATM，你去ATM取钱，如果你去了恰巧里面有人，那么你肯定是进不去的，必须等里面的人出来之后你才能进去，同样的，如果你正在取钱，如果外面还有人等着取钱，那么无论如何他都必须等你取完出来，他才能进去，要么他不取了回家去。

# 三、Redis实现的分布式锁 #

简单的介绍了分布式和分布式锁，之后我们现在来看看如何实现一个分布式锁，先看我之前使用Redis写个一个分布式锁，看看有什么问题？

public Boolean lock(String key, Long waitTime, Long expireTime) {
    
            String value = UUID.randomUUID().toString().replaceAll("-", "").toLowerCase();
            Boolean flag = setNx(key, value, expireTime, TimeUnit.SECONDS);
    
            // 尝试获取锁 成功返回
            if (flag) {
                return flag;
            } else {
                // 获取失败
    
                // 现在时间
                long newTime = System.currentTimeMillis();
                // 等待过期时间
                long loseTime = newTime + waitTime;
    
                // 不断尝试获取锁成功返回 11 < 11
                while (System.currentTimeMillis() < loseTime) {
    
                    Boolean testFlag = setNx(key, value, expireTime, TimeUnit.MILLISECONDS);
                    if (testFlag) {
                        return testFlag;
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
    
                    }
                }
            }
            return false;
        }

首先尝试获取锁，如果获取到了同时设置过期时间（原子操作，防止死锁），获取到了直接返回，简单看没什么问题，但是如果说，我设置了10秒的过期时间，但是我的业务执行了12秒，那么此时其他线程也进来了，那么这个锁根本就没有起到任何作用，注意：大家千万不要说那我把过期时间设置为1分钟设置10分钟不就好了，千万不要这么干，治标不治本。其实办法肯定是有的，在获取到锁之后，然后开一个守护线程，判断当前线程时候执行结束，如果没有那就重置锁的过期时间。但是我们这里就不说了，而是直接用别人封装好的框架。

# 四、Redisson分布式锁 #

### 1、首先引入maven ###

<dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson-spring-boot-starter</artifactId>
        <version>3.10.6</version>
    </dependency>

注意：我这里引入的是redisson和springboot的集成包，网上一些教程可能是引入如下配置

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

如果你引入的就是redisson的依赖包，如果该依赖包的版本低于3.5会需要你再引入

<dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty-all</artifactId>
        <version>4.1.25.Final</version>
    </dependency>
     
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>2.9.0</version>
    </dependency>
     
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.0</version>
    </dependency>

### 2、构建Redisson实例（基于SpringBoot） ###

**配置redis信息**

spring:
      application:
        name: spring-cloud-product
      redis:
        port: 6379
        host: 127.0.0.1
        password:
        database: 0
        timeout: 2000

**配置redisson**

![2019120310093116.png][]

**新建一个redisson-single.yml的配置文件 下面是单机配置**

singleServerConfig:
      idleConnectionTimeout: 10000
      pingTimeout: 1000
      connectTimeout: 10000
      timeout: 3000
      retryAttempts: 3
      retryInterval: 1500
      reconnectionTimeout: 3000
      failedAttempts: 3
      password: null
      subscriptionsPerConnection: 5
      clientName: null
      address: "redis://127.0.0.1:6379"
      subscriptionConnectionMinimumIdleSize: 1
      subscriptionConnectionPoolSize: 50
      connectionMinimumIdleSize: 32
      connectionPoolSize: 64
      database: 0
      #在最新版本中dns的检查操作会直接报错 所以我直接注释掉了
      #dnsMonitoring: false
      dnsMonitoringInterval: 5000
    threads: 0
    nettyThreads: 0
    codec: !<org.redisson.codec.JsonJacksonCodec> {}
    transportMode : "NIO"

**RedissonConfig配置类 来配置你的redisson**

@Configuration
    public class RedssonConfig {
        @Bean(destroyMethod="shutdown")
        public RedissonClient redisson() throws IOException {
            RedissonClient redisson = Redisson.create(Config.fromYAML(new ClassPathResource("redisson-single.yml").getInputStream()));
            return redisson;
        }
    }

### 3、使用 ###

其实单从使用来说是非常简单的，这里需要跟大家说一点，就是lock()这个方法，我们先看源码，这个方法是可以设置过期时间的，但是它并不会去进行检查任务是否执行结束，如果任务没有执行结束，然后锁的过期时间到了，线程中断，就会出现异常。

public void lock(long leaseTime, TimeUnit unit) {
            try {
                this.lock(leaseTime, unit, false);
            } catch (InterruptedException var5) {
                throw new IllegalStateException();
            }
        }

**异常信息**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly96aGFuZ2hhaXlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70][]

### 4、较为完善的方法，lock() ###

这个方法不需要传递任何参数，它的底层方法会通过我们刚才说的原理，去校验当前任务是否执行结束，如果没有执行结束，那么相应的就会延长锁的过期时间。

**底层实现**

private void lock(long leaseTime, TimeUnit unit, boolean interruptibly) throws InterruptedException {
            long threadId = Thread.currentThread().getId();
            Long ttl = this.tryAcquire(leaseTime, unit, threadId);
            if (ttl != null) {
                RFuture<RedissonLockEntry> future = this.subscribe(threadId);
                this.commandExecutor.syncSubscription(future);
    
                try {
                
                    // 校验任务是否执行结束
                    while(true) {
                        ttl = this.tryAcquire(leaseTime, unit, threadId);
                        if (ttl == null) {
                            return;
                        }
    
                        if (ttl >= 0L) {
                            try {
                                this.getEntry(threadId).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                            } catch (InterruptedException var13) {
                                if (interruptibly) {
                                    throw var13;
                                }
    
                                this.getEntry(threadId).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                            }
                        } else if (interruptibly) {
                            this.getEntry(threadId).getLatch().acquire();
                        } else {
                            this.getEntry(threadId).getLatch().acquireUninterruptibly();
                        }
                    }
                } finally {
                    this.unsubscribe(future, threadId);
                }
            }
        }

# 五、秒杀案例 #

**编写一个秒杀接口**

@Autowired
    private RedissonClient redissonClient;
     
    @Override
    public boolean decrementProductStore(Long productId, Integer productQuantity) {
        String key = "dec_store_lock_" + productId;
        RLock lock = redissonClient.getLock(key);
        try {
            //加锁 操作很类似Java的ReentrantLock机制
            lock.lock();
            ProductInfo productInfo = productInfoMapper.selectByPrimaryKey(productId);
            //如果库存为空
            if (productInfo.getProductStock() == 0) {
               return false;
            }
            //简单减库存操作 没有重新写其他接口了
            productInfo.setProductStock(productInfo.getProductStock() - 1);
            productInfoMapper.updateByPrimaryKey(productInfo);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {
            //解锁
            lock.unlock();
        }
        return true;
    }

**写一个简单的测试请求 **

@GetMapping("test")
    public String createOrderTest() {
        if (!productInfoService.decrementProductStore(1L, 1)) {
            return "库存不足";
        }
        OrderMaster orderMaster = new OrderMaster();
        //未支付
        orderMaster.setOrderStatus(0);
        //未支付
        orderMaster.setPayStatus(0);
        orderMaster.setBuyerName(name);
        orderMaster.setBuyerAddress("湖南长沙");
        orderMaster.setBuyerPhone("18692794847");
        orderMaster.setOrderAmount(BigDecimal.ZERO);
        orderMaster.setCreateTime(DateUtils.getCurrentDate());
        orderMaster.setOrderId(UUID.randomUUID().toString().replaceAll("-", ""));
        orderMasterService.insert(orderMaster);
        return "创建订单成功";
    }

**使用ab做接口测试**

![20191203101440965.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly96aGFuZ2hhaXlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1][]

![20191203101509127.png][]

ab -n 300 -c 300 请求地址；-n 的含义就是你做多少个请求；-c 的含义就是多少个用户并发请求。数据库中的商品已经全部被秒杀完 并未出现超库存的情况。如果对ab不是太了解可以看看这篇文章 （[ab][]）。其实Redisson还有其他好多的方法来解决现在互联网中的好多问题，但是我这里就不一一介绍了，大家如果想了解更多的东西，可以去Redisson官网。（[Redisson官网][Redisson]）

# 附： #

### RedissonLocker的具体实现类 ###

public class RedissonLockerImpl implements RedissonLocker {
     
    	@Autowired
    	private RedissonClient redissonClient;
    	
    	/**************************可重入锁**************************/
    	
    	/**
    	 * 拿不到lock就不罢休，不然线程就一直block
    	 * 没有超时时间,默认30s
    	 * 
    	 * @param lockKey
    	 * @return
    	 */
    	@Override
    	public RLock lock(String lockKey) {
    		RLock lock = redissonClient.getLock(lockKey);
    		lock.lock();
    		return lock;
    	}
     
    	/**
    	 * 自己设置超时时间
    	 * 
    	 * @param lockKey 锁的key
    	 * @param timeout 秒 如果是-1，直到自己解锁，否则不会自动解锁
    	 * @return
    	 */
    	@Override
    	public RLock lock(String lockKey, int timeout) {
    		RLock lock = redissonClient.getLock(lockKey);
    		lock.lock(timeout, TimeUnit.SECONDS);
    		return lock;
    	}
    	
    	/**
    	 * 自己设置超时时间
    	 * 
    	 * @param lockKey 锁的key
    	 * @param unit 锁时间单位
    	 * @param timeout 超时时间
    	 * 
    	 */
    	@Override
    	public RLock lock(String lockKey, TimeUnit unit, int timeout) {
    		RLock lock = redissonClient.getLock(lockKey);
    		lock.lock(timeout, unit);
    		return lock;
    	}
     
    	/**
    	 *  尝试加锁，最多等待waitTime，上锁以后leaseTime自动解锁
    	 * @param lockKey   锁key
    	 * @param unit      锁时间单位
    	 * @param waitTime  等到最大时间，强制获取锁
    	 * @param leaseTime 锁失效时间
    	 * @return 如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false
    	 */
    	@Override
    	public boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
    		RLock lock = redissonClient.getLock(lockKey);
    		try {
    			return lock.tryLock(waitTime, leaseTime, unit);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		return false;
    	}
    	
    	
    	
    	/**************************公平锁**************************/
    	/**
    	 *   尝试加锁，最多等待waitTime，上锁以后leaseTime自动解锁
    	 * @param lockKey   锁key
    	 * @param unit      锁时间单位
    	 * @param waitTime  等到最大时间，强制获取锁
    	 * @param leaseTime 锁失效时间
    	 * @return 如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false
    	 */
    	public boolean fairLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
    		RLock fairLock = redissonClient.getFairLock(lockKey);
    		try {
    			return fairLock.tryLock(waitTime, leaseTime, unit);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		return false;
    	}
     
    	/**
    	 * 释放锁
    	 * @param lockKey 锁key
    	 */
    	@Override
    	public void unlock(String lockKey) {
    		RLock lock = redissonClient.getLock(lockKey);
    		lock.unlock();
    	}
     
    	/**
    	 * 释放锁
    	 */
    	@Override
    	public void unlock(RLock lock) {
    		lock.unlock();
    	}
    }

### 业务代码中使用 ###

String lockKey = userId;
    // 公平加锁，60秒后锁自动释放
    boolean isLocked = false;
    try {
    	isLocked = redissonLocker.fairLock(lockKey , TimeUnit.SECONDS, 3, 60);
    	if (isLocked) { // 如果成功获取到锁就继续执行
    		// 执行业务代码操作
    		return GlobalResponse.success();
    	} else { // 未获取到锁
    		return GlobalResponse.fail(500, "请勿重复点击！！");
    	}
    } catch (Exception e) {
    	return GlobalResponse.fail(500, e.getMessage());
    } finally {
    	if (isLocked) { // 如果锁还存在，在方法执行完成后，释放锁
    		redissonLocker.unlock(lockKey);
    	}
    }

[2019120310093116.png]: https://img-blog.csdnimg.cn/2019120310093116.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly96aGFuZ2hhaXlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191203093913479.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly96aGFuZ2hhaXlhbmcuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191203101440965.png]: https://img-blog.csdnimg.cn/20191203101440965.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly96aGFuZ2hhaXlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191203101501122.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly96aGFuZ2hhaXlhbmcuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191203101509127.png]: https://img-blog.csdnimg.cn/20191203101509127.png
[ab]: https://www.cnblogs.com/greatluoluo/p/5725978.html
[Redisson]: https://redisson.org/