如何实现分布式锁 分布式锁的解决方案

最新推荐文章于 2024-05-11 20:01:04 发布
最新推荐文章于 2024-05-11 20:01:04 发布
阅读量220 收藏 1
点赞数
分类专栏： SpringBoot JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43700943/article/details/108757193
版权

一、什么是超卖

  • 举例：某件商品库存数量10件，结果卖出了15件

二、超卖现象一

  1. 系统中库存为1，但是产生了两笔订单

  2. 解决方法

  • 扣减库存不在程序中进行，而是通过数据库
  • 向数据库传递库存增量，扣减1个库存，增量为-1
    先 - 在数据库update语句计算库存，通过update行锁解决并发
 <update id="updateProductCount">
      update product
      set count = count - #{purchaseProductNum,jdbcType=INTEGER},
      update_user = #{updateUser,jdbcType=VARCHAR},
       update_time = #{updateTime,jdbcType=TIME}
      where id = #{id,jdbcType=INTEGER}
    </update>

三、超卖现象二

  1. 系统中库存变为 -1
  2. 产生原因：并发检验库存，造成库存充足的假象，update更新库存，导致库存为负数
  3. 解决方法：校验库存、扣减库存统一加锁，使之成为原子性的操作，并发时只有获得锁的线程才能校验、扣减库存

使用synchronized锁，注意(事务要在锁中)
使用ReentrantLock锁解决（并发包中的锁）

 private Lock lock = new ReentrantLock();

    public Integer createOrder() throws Exception{
        Product product = null;

        lock.lock();
        try {
            TransactionStatus transaction1 = platformTransactionManager.getTransaction(transactionDefinition);
            product = productMapper.selectByPrimaryKey(purchaseProductId);
            if (product==null){
                platformTransactionManager.rollback(transaction1);
                throw new Exception("购买商品："+purchaseProductId+"不存在");
            }

            //商品当前库存
            Integer currentCount = product.getCount();
            System.out.println(Thread.currentThread().getName()+"库存数："+currentCount);
            //校验库存
            if (purchaseProductNum > currentCount){
                platformTransactionManager.rollback(transaction1);
                throw
                        new Exception("商品"+purchaseProductId+"仅剩"+currentCount+"件，无法购买");
            }

            productMapper.updateProductCount(purchaseProductNum,"xxx",new Date(),product.getId());
            platformTransactionManager.commit(transaction1);
        }finally {
            lock.unlock();
        }

        TransactionStatus transaction = platformTransactionManager.getTransaction(transactionDefinition);
        Order order = new Order();
        order.setOrderAmount(product.getPrice().multiply(new BigDecimal(purchaseProductNum)));
        order.setOrderStatus(1);//待处理
        order.setReceiverName("xxx");
        order.setReceiverMobile("13311112222");
        order.setCreateTime(new Date());
        order.setCreateUser("xxx");
        order.setUpdateTime(new Date());
        order.setUpdateUser("xxx");
        orderMapper.insertSelective(order);

        OrderItem orderItem = new OrderItem();
        orderItem.setOrderId(order.getId());
        orderItem.setProductId(product.getId());
        orderItem.setPurchasePrice(product.getPrice());
        orderItem.setPurchaseNum(purchaseProductNum);
        orderItem.setCreateUser("xxx");
        orderItem.setCreateTime(new Date());
        orderItem.setUpdateTime(new Date());
        orderItem.setUpdateUser("xxx");
        orderItemMapper.insertSelective(orderItem);
        platformTransactionManager.commit(transaction);
        return order.getId();
    }

单体应用锁的局限性不能跨jvm，所以需要使用分布式锁

四、基于数据库悲观锁的分布式锁

基于数据库实现分布式锁(跨进程)
步骤：

  1. 多个进程、多个线程访问共同组件数据库
  2. 通过select…for update 访问同一条数据
  3. for update锁定数据，其他线程只能等待

优点：
简单方便、易于理解、易于操作

缺点：
并发量大时，对数据库压力较大

select * from distribute_lock where business_code='demo' for update

@RestController
@Slf4j
public class DemoController {
    @Resource
    private DistributeLockMapper distributeLockMapper;

    @RequestMapping("singleLock")
    @Transactional(rollbackFor = Exception.class)
    public String singleLock() throws Exception {
        log.info("我进入了方法！");
        DistributeLock distributeLock = distributeLockMapper.selectDistributeLock("demo");
        if (distributeLock==null) throw new Exception("分布式锁找不到");
        log.info("我进入了锁！");
        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "我已经执行完成！";
    }
}

五、基于Redis的Setnx实现分布式锁

  1. 实现原理：
    1. 获取锁的Redis命令
    2. SET resource_name my_random_value NX PX 30000
      解释：
      resource_name ：资源名称，可根据不同的业务区分不同的锁
      my_random_value ：随机值，每个线程的随机值都不同，用于释放时的校验
      NX：key不存在时设置成功，key存在则设置不成功
      PX：自动失效时间，出现异常情况，锁可以过期失效
    3. 利用NX的原子性，多个线程并发时，只有一个线程可以设置成功
    4. 设置成功即获得锁，可以执行后续的业务
    5. 如果出现异常，过了锁的有效期，锁自动释放
    6. 释放锁采用Redis的delete命令
    7. 释放锁时校验之前设置的随机数，相同才能释放
    8. 释放锁的LUA脚本

自己的理解：使用Redis的Setnx这个特性，给一个key赋值，key存在择赋值不成功，key不存在赋值成功

LUA脚本

if redis.call("get",KEYS[1])==ARGV[1] then
	return redis.call("del",KEYS[1])
else 
	return 0
end

redis实现分布式锁代码

RedisLock.java

@Slf4j
public class RedisLock implements AutoCloseable {

    private RedisTemplate redisTemplate;
    private String key;
    private String value;
    //单位：秒
    private int expireTime;

    public RedisLock(RedisTemplate redisTemplate,String key,int expireTime){
        this.redisTemplate = redisTemplate;
        this.key = key;
        this.expireTime=expireTime;
        this.value = UUID.randomUUID().toString();
    }

    /**
     * 获取分布式锁
     * @return
     */
    public boolean getLock(){
        RedisCallback<Boolean> redisCallback = connection -> {
            //设置NX
            RedisStringCommands.SetOption setOption = RedisStringCommands.SetOption.ifAbsent();
            //设置过期时间
            Expiration expiration = Expiration.seconds(expireTime);
            //序列化key
            byte[] redisKey = redisTemplate.getKeySerializer().serialize(key);
            //序列化value
            byte[] redisValue = redisTemplate.getValueSerializer().serialize(value);
            //执行setnx操作
            Boolean result = connection.set(redisKey, redisValue, expiration, setOption);
            return result;
        };

        //获取分布式锁
        Boolean lock = (Boolean)redisTemplate.execute(redisCallback);
        return lock;
    }

    public boolean unLock() {
        String script = "if redis.call(\"get\",KEYS[1]) == ARGV[1] then\n" +
                "    return redis.call(\"del\",KEYS[1])\n" +
                "else\n" +
                "    return 0\n" +
                "end";
        RedisScript<Boolean> redisScript = RedisScript.of(script,Boolean.class);
        List<String> keys = Arrays.asList(key);

        Boolean result = (Boolean)redisTemplate.execute(redisScript, keys, value);
        log.info("释放锁的结果："+result);
        return result;
    }


    @Override
    public void close() throws Exception {
        unLock();
    }
}

RedisLockController.java

@RestController
@Slf4j
public class RedisLockController {
    @Autowired
    private RedisTemplate redisTemplate;

    @RequestMapping("redisLock")
    public String redisLock(){
        log.info("我进入了方法！");
        try (RedisLock redisLock = new RedisLock(redisTemplate,"redisKey",30)){
            if (redisLock.getLock()) {
                log.info("我进入了锁！！");
                Thread.sleep(15000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        log.info("方法执行完成");
        return "方法执行完成";
    }
}

六、基于Zookeeper的瞬间节点实现分布式锁

  1. Zookeeper的数据结构
    是一棵树，持久节点：zk会话结束和zk重启这些会话都是不会消失的，瞬时节点：瞬时节点不可再有子节点，会话结束后瞬时节点自动消失
  2. Zookeeper的观察器
    可设置观察器的3个方法：getData();getChildren();exists()
    节点数据发生变化，发送给客户端
    观察器只能控制一次，再监控需重新设置
  3. 实现原理：
    利用Zookeeper的瞬时有序节点的特性
    多线程并发创建瞬时节点时，得到有序的序列
    序号最小的线程获得锁
    其他的线程则监听自己序号的前一个序号
    前一个线程执行完成，删除自己序号的节点
    下一个序号的线程得到通知，继续执行
    创建节点时，已经确定了线程的执行顺序

ZkLock.java

@Slf4j
public class ZkLock implements AutoCloseable, Watcher {

    private ZooKeeper zooKeeper;
    private String znode;

    public ZkLock() throws IOException {
        this.zooKeeper = new ZooKeeper("localhost:2181",
                10000,this);
    }

    public boolean getLock(String businessCode) {
        try {
            //创建业务 根节点
            Stat stat = zooKeeper.exists("/" + businessCode, false);
            if (stat==null){
                zooKeeper.create("/" + businessCode,businessCode.getBytes(),
                        ZooDefs.Ids.OPEN_ACL_UNSAFE,
                        CreateMode.PERSISTENT);
            }

            //创建瞬时有序节点  /order/order_00000001
            znode = zooKeeper.create("/" + businessCode + "/" + businessCode + "_", businessCode.getBytes(),
                    ZooDefs.Ids.OPEN_ACL_UNSAFE,
                    CreateMode.EPHEMERAL_SEQUENTIAL);

            //获取业务节点下 所有的子节点
            List<String> childrenNodes = zooKeeper.getChildren("/" + businessCode, false);
            //子节点排序
            Collections.sort(childrenNodes);
            //获取序号最小的（第一个）子节点
            String firstNode = childrenNodes.get(0);
            //如果创建的节点是第一个子节点，则获得锁
            if (znode.endsWith(firstNode)){
                return true;
            }
            //不是第一个子节点，则监听前一个节点
            String lastNode = firstNode;
            for (String node:childrenNodes){
                if (znode.endsWith(node)){
                    zooKeeper.exists("/"+businessCode+"/"+lastNode,true);
                    break;
                }else {
                    lastNode = node;
                }
            }
            synchronized (this){
                wait();
            }

            return true;

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





    @Override
    public void close() throws Exception {
        zooKeeper.delete(znode,-1);
        zooKeeper.close();
        log.info("我已经释放了锁！");
    }

    @Override
    public void process(WatchedEvent event) {
        if (event.getType() == Event.EventType.NodeDeleted){
            synchronized (this){
                notify();
            }
        }
    }
}

七、基于分布式Zookeeper的Curator客户端实现分布式锁

  1. curator已经实现了分布式锁的方法
  2. 直接调用即可
    @Test
    public void testCuratorLock(){
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        CuratorFramework client = CuratorFrameworkFactory.newClient("localhost:2181", retryPolicy);
        client.start();
        InterProcessMutex lock = new InterProcessMutex(client, "/order");
        try {
            if ( lock.acquire(30, TimeUnit.SECONDS) ) {
                try  {
                    log.info("我获得了锁！！！");
                }
                finally  {
                    lock.release();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        client.close();
    }

@RestController
@Slf4j
public class ZookeeperController {
    @Autowired
    private CuratorFramework client;

    @RequestMapping("zkLock")
    public String zookeeperLock(){
        log.info("我进入了方法！");
        try (ZkLock zkLock = new ZkLock()) {
            if (zkLock.getLock("order")){
                log.info("我获得了锁");
                Thread.sleep(10000);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        log.info("方法执行完成！");
        return "方法执行完成！";
    }

    @RequestMapping("curatorLock")
    public String curatorLock(){
        log.info("我进入了方法！");
        InterProcessMutex lock = new InterProcessMutex(client, "/order");
        try{
            if (lock.acquire(30, TimeUnit.SECONDS)){
                log.info("我获得了锁！！");
                Thread.sleep(10000);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                log.info("我释放了锁！！");
                lock.release();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        log.info("方法执行完成！");
        return "方法执行完成！";
    }
}

八、基于Redisson实现分布式锁

明明说JAVA
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中几种分布式锁的实现
qq_37400096的博客
10-16 1182
分布式锁在实际中应用非常之广泛，对于互联网项目电商项目，秒杀活动中不能出现超买超卖的现象，分布式锁在其中具有重要的意义。
商品扣减库存好一点儿的方式（只通过数据库处理）
Jarvis's Blog
02-10 2014
前言 相信很多小伙伴在面试一些有涉及订单相关的公司时，技术面都有：“商品扣减库存怎么操作？你的SQL是怎么写的？” 如果你回答说，就很简单啊： update stock_table set stock=#{扣减后的库存} where product_id=#{product} 那我估计面试官就会对你摇摇头了 正文 我们分析在商品购买的过程中，库存的扣减过程 根据商品id查询商品的剩余库存 根据下单的数量，计算剩余库存是否足够，如果库存不足就返回相应的提示；相反，则减去扣除的库存得到最新的库存剩余值 更
大数据最全图解curator如何实现zookeeper分布式锁_curator 锁，非科班程序员金三银四求职经历
最新发布
2401_84591984的博客
05-11 2019
至此，Zookeeper系列的内容已出：1.zookeeper集群搭建2.Zookeeper集群选举机制3.Paxos算法解析4.Zookeeper（curator）实现分布式锁案例紧接着上一篇的内容，从源码层面来看curator是如何实现zookeeper分布式锁的？zk用/lock节点作为分布式锁，当不同的客户端到zk竞争这把锁的时候，zk会按顺序给不同的客户端创建一个临时子节点，挂在作为分布式锁的节点下面。假设第一个来到的客户端为A，第二个来到的是B，分布式锁节点下挂的第一个节点就是A（
基于数据库实现分布式锁
weixin_41996755的博客
02-15 1673
分布式锁实现
数据库实现分布式锁总结笔记
⛄沉淀分享成长--长久的沉淀势必会收获到你想要的，那些旅途上的果实
04-04 5163
✅作者简介：大家好我是poizxc2014 📖个人主页：poizxc2014的博客_CSDN博客-数据库,mysql,java领域博主 🔥💖如果觉得博主的文章还不错的话，请👍三连支持一下博主哦🤞
Redis Template实现分布式锁的实例代码
09-09
Redis 分布式锁是一种在分布式系统中实现锁的常见方法，其核心在于利用Redis的原子性操作来保证并发环境下的安全。在本例中，使用了`Redis Template`，它是Spring Data Redis提供的一个高级API，方便进行Redis的操作...
使用MySQL实现一个分布式锁
09-08
`lockKey`字段设置为唯一索引，这样当尝试插入新的记录时，如果`lockKey`已存在，就会导致插入操作失败，从而实现锁的效果。 以下是如何使用MySQL实现分布式锁的一个简单示例： 1. **尝试获取锁**：通过`tryLock`...
redisson实现分布式锁
12-16
在分布式系统中，锁是保证数据一致性的重要工具，而Redisson的分布式锁则为Java开发者提供了一种高效且可靠的解决方案。 首先，让我们深入理解分布式锁的概念。分布式锁是在分布式系统中，为了确保多个节点对共享...
redis实现分布式锁,自旋式加锁,lua原子性解锁
07-16
在分布式系统中，为了保证数据的一致性和安全性，分布式锁是一种常见的解决方案。Redis作为一个高性能的键值存储系统，常被用作实现分布式锁的工具。本文将深入探讨如何使用Redis实现分布式锁，以及如何利用自旋式...
MySQL借助DB实现分布式锁思路详解
09-09
MySQL借助DB实现分布式锁是一种在分布式环境中协调多个节点访问共享资源的方法。分布式锁的主要目标是保证数据的一致性...在需要高性能和高可用性的分布式锁解决方案时，考虑使用Redis或Zookeeper等专为此设计的组件。
distributeLock:分布式锁和配置管理中心的实现，采用zookeeper的全局有序的特性来实现
06-06
#分布式锁和配置管理中心的实现 ##distributelock包下实现了分布式锁，利用zookeeper，创建一个临时时序的节点类型，采用zookeeper的全局有序的特性来实现。 ###具体步骤： 1.客户端调用create()方法创建名为“grouplock/sub”的节点，需要注意的是，这里节点的创建类型需要设置为EPHEMERAL_SEQUENTIAL。 2.客户端调用getChildren(“grouplock”)方法来获取所有已经创建的子节点，注意，这里不注册任何Watcher。 3.客户端获取到所有子节点path之后，如果发现自己在步骤1中创建的节点序号最小，那么就认为这个客户端获得了锁。 如果在步骤3中发现自己并非所有子节点中最小的，说明自己还没有获取到锁。此时客户端需要找到比自己小的那个节点，然后对其调用exist()方法，同时注册事件监听。 之后当这个被关注的节点被移
zk使用curator实现分布式锁
09-20
zookeeper通过使用curator实现分布式锁来保证数据的一致性。 zookeeper通过使用curator实现分布式锁来保证数据的一致性。
分布式锁的三种实现方式
lingshengxiyou的博客
04-07 511
这里推荐一个Apache的开源库Curator，它是一个ZooKeeper客户端，Curator提供的InterProcessMutex是分布式锁的实现，acquire方法用于获取锁，release方法用于释放锁。（1）获取锁的时候，使用setnx加锁，并使用expire命令为锁添加一个超时时间，超过该时间则自动释放锁，锁的value值为一个随机生成的UUID，通过此在释放锁的时候进行判断。（3）释放锁的时候，通过UUID判断是不是该锁，若是该锁，则执行delete进行锁释放。利用select …
分布式基础：Curator实现Zookeeper分布式锁
ReturnTmp的博客
07-21 2571
官网的说法curator是一个Java/JVM客户端库，用于zookeeper，一个分布式协调服务。它包括一个高级API框架和实用程序，使ApacheZooKeeper的使用更加简单和可靠。它还包括常见用例和扩展的方法，如服务发现和Java8异步DSL。Curator使用手册-腾讯云开发者社区-腾讯云配置zookeeper集群参考;https。...........................
BCD详细测试说明
热门推荐
wolfsun3的专栏
09-30 1万+
BCD详细测试说明 一、BCD简介 BCD全称Boot Configuration Data（引导配置数据），了解BCD之前，需要先大体了解一下windows系统启动过程：         BIOS-->MBR-->DPT-->DBR-->BootMgr-->BCD-->Winload.exe(bootmgfw.efi)-->内核加载-->整个windows系统   说明： 1.BCD
分布式锁学习详解
qq_45228323的博客
12-20 503
1. 分布式锁 1.1 什么是分布式锁 在我们进行单机应用开发涉及并发同步的时候，我们往往采用synchronized或者ReentrantLock的方式来解决多线程间的代码同步问题。但是当我们的应用是在分布式集群工作的情况下，那么就需要一种更加高级的锁机制，来处理种跨机器的进程之间的数据同步问题，这就是分布式锁。 分布式锁，是控制分布式系统之间同步访问共享资源的一种方式。在分布式系统中，常常需要协调他们的动作。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源，那么访问这些资源的时候，往往需要
11张图深入理解分布式锁原理（转载）
moose_killer的博客
02-25 499
什么是分布式锁？它能干什么？ 单体系统中，在高并发场景下想要访问共享资源的时候，我们需要通过加锁的方式来保证共享资源并发的安全性，确保在同一时刻只有一个线程对共享资源进行操作。相信大家对于Java提供的synchronized关键字以及Lock锁都不陌生，在实际的项目中大家都使用过。如下图所示，在同一个JVM进程中，Thread1获得锁之后，对共享资源进行操作，其他线程未获得锁的线程只能等待Thread1释放后才能进行对应的操作。 但是随着业务的不断发展，原先的单体应用被拆分为多个微服务，每个微.
ZooKeepe分布式锁——Curator分布式锁源码详解
“实用”是软件压倒一切的要素
05-10 1018
官方文档上这么解释ZooKeeper，它是一个分布式协调框架，是Apache Hadoop 的一个子项目，它主要是用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步服务、集群管理、分布式应用配置项的管理等。 ZooKeeper主要有如下两个核心的概念：文件系统数据结构 + 监听通知机制。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值