赞
踩
要想说什么是分布式,那么首先要知道分布式之前的系统是什么样的架构,之前的架构又存在什么样的问题?
分布式之前就是单体架构,单体架构顾名思义就是将所有的业务功能打包在一个应用中,然后部署在服务器上。如果我们把单体架构比作一个汽车工厂,那么从汽车发动机到汽车上的一个螺丝钉都需要由它来负责完成,如果有一天这家工厂由于自然灾害的原因导致业务量急剧下滑,甚至停止生产,那么这个整个工厂无论是造发动机的,还是造螺丝钉的全部都得停工。落实到互联网就是单体架构开发成本高、出现故障影响的范围大,很难适应现在的互联网项目。
既然单体架构不足以解决现在存在的高并发、高性能、高可用的要求,那么分布式就来了,原来我们把一个汽车所有的零件都放在一家工厂进行生产,结果会出现上面停工的情况,那么分布式怎么解决的?所谓分布式就是把所有的零件分开生产,每个工厂根据自己的特长来生产相应的汽车配件,最后统一组装,即使因为一些其他原因,导致某个工厂停止了生产,但是依旧不影响其他工厂的生产进度,我们可以通过小的代价来寻找其他工厂来代替停工的工厂,确保我们的生产任务可以正常的运转。
解释这个问题之前,我们先来说下,如果没有分布式锁会存在什么问题,举个经典的例子,如果我们有一个购物网站,有一件商品只有10件可卖,此时用户A进来后还有1个库存,然后用户A下单付款,扣减库存,在用户A付款的这个过程中,恰好用户B进来了,也看到还有一个库存,用户B也开始下单付款,扣减库存,那么这个过程很明显已经出了问题,出现了超卖的问题。
如果有了分布式锁就不会出现超卖问题,举个简单的例子,分布式就像是银行的ATM,你去ATM取钱,如果你去了恰巧里面有人,那么你肯定是进不去的,必须等里面的人出来之后你才能进去,同样的,如果你正在取钱,如果外面还有人等着取钱,那么无论如何他都必须等你取完出来,他才能进去,要么他不取了回家去。
简单的介绍了分布式和分布式锁,之后我们现在来看看如何实现一个分布式锁,先看我之前使用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分钟不就好了,千万不要这么干,治标不治本。其实办法肯定是有的,在获取到锁之后,然后开一个守护线程,判断当前线程时候执行结束,如果没有那就重置锁的过期时间。但是我们这里就不说了,而是直接用别人封装好的框架。
- <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>
配置redis信息
- spring:
- application:
- name: spring-cloud-product
- redis:
- port: 6379
- host: 127.0.0.1
- password:
- database: 0
- timeout: 2000
配置redisson
新建一个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;
- }
- }
其实单从使用来说是非常简单的,这里需要跟大家说一点,就是lock()这个方法,我们先看源码,这个方法是可以设置过期时间的,但是它并不会去进行检查任务是否执行结束,如果任务没有执行结束,然后锁的过期时间到了,线程中断,就会出现异常。
- public void lock(long leaseTime, TimeUnit unit) {
- try {
- this.lock(leaseTime, unit, false);
- } catch (InterruptedException var5) {
- throw new IllegalStateException();
- }
- }
异常信息
这个方法不需要传递任何参数,它的底层方法会通过我们刚才说的原理,去校验当前任务是否执行结束,如果没有执行结束,那么相应的就会延长锁的过期时间。
底层实现
- 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做接口测试
ab -n 300 -c 300 请求地址;-n 的含义就是你做多少个请求;-c 的含义就是多少个用户并发请求。数据库中的商品已经全部被秒杀完 并未出现超库存的情况。如果对ab不是太了解可以看看这篇文章 (ab)。其实Redisson还有其他好多的方法来解决现在互联网中的好多问题,但是我这里就不一一介绍了,大家如果想了解更多的东西,可以去Redisson官网。(Redisson官网)
- 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);
- }
- }
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。