基于秒杀-----分布式锁----lua脚本

最新推荐文章于 2024-07-25 22:13:53 发布
最新推荐文章于 2024-07-25 22:13:53 发布
阅读量1.1k 收藏 2
点赞数 1
分类专栏： redis springboot 文章标签： 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64035133/article/details/130895092
版权

基于商品显示秒杀-一人一单业务_xzm_的博客-CSDN博客改进

分布式锁：满足分布式系统或集群模式下多进程可见并且互斥的锁

 分布式锁的五个基本要求：多进程可见，互斥，高可用，高性能，安全性

三种实现方式

 redis

 1.创建获取锁删除锁的工具类

public interface ILock {

    /**
     * 获取锁
     * @param timeoutSec 自动超时时间
     * @return
     */
    boolean tryLock(long timeoutSec);

    /**
     * 释放锁
     */
    void unlock();

}

package com.hmdp.utils;

import org.springframework.data.redis.core.StringRedisTemplate;

import java.util.concurrent.TimeUnit;

public class SimpleRedisLock implements ILock{

    public String name;
    public StringRedisTemplate stringRedisTemplate;

    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    private static final String KEY_PREFIX="lock:";



    @Override
    public boolean tryLock(long timeoutSec) {
        //获取线程标识
        long thread = Thread.currentThread().getId();
        //获取锁
        Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFIX + name, thread + "", timeoutSec, TimeUnit.SECONDS);

        return Boolean.TRUE.equals(aBoolean);
    }

    @Override
    public void unlock() {
        //释放锁
        stringRedisTemplate.delete(KEY_PREFIX+name);
    }
}

2.修改代码

@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
   @Resource
    private ISeckillVoucherService iSeckillVoucherService;
   @Resource
   private RedisIdWorker redisIdWorker;
   @Autowired
   private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result seckillVoucher(Long voucherId) {
        //查询优惠卷
        SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);
        //判断秒杀是否开始
        if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
            //秒杀尚未开始
            return Result.fail("秒杀尚未开始，请耐心等待");
        }
        //判断秒杀是否结束
        if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
            //秒杀已经结束
            return Result.fail("本次秒杀已经结束");
        }
        //秒杀处于正常时间段
        //判断库存是否充足
        if (voucher.getStock()<1) {
            //库存不足
            return Result.fail("本次秒杀已经被抢完");
        }
        //库存充足

        //从拦截器中获取用户id
        Long userId = UserHolder.getUser().getId();
        //对相同的id进行加锁
//        synchronized(userId.toString().intern()) {
            //获取代理对象
//            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            //在service中添加createVoucherOrder方法，也可利用idea代码修复功能自动添加
//            return proxy.createVoucherOrder(voucherId);
//            return createVoucherOrder(voucherId);
//        }

        //创建锁对象
        SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);
        //获取锁
        boolean tryLock = lock.tryLock(500);

        if (!tryLock) {
            //获取锁失败
            return Result.fail("每人仅限一单");
        }
        //获取锁成功

        try {
            return createVoucherOrder(voucherId);
        } finally {
            //释放锁
            lock.unlock();
        }


    }

    @Transactional
    public  Result createVoucherOrder(Long voucherId) {
        //从拦截器中获取用户id
        Long userId = UserHolder.getUser().getId();
         /**
          * 进行判断，一人一单
          */
         int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
         if (count > 0) {
             //用户已经购买过商品
             return Result.fail("每位用户仅限购一单");
         }

         //扣减库存
         boolean update = iSeckillVoucherService.update().setSql("stock = stock - 1")
                 .eq("voucher_id", voucherId)
                 .gt("stock", 0)
                 .update();
         //判断库存扣减是否成功
         if (!update) {
             //库存扣减失败，返回信息
             return Result.fail("库存不足");
         }
         //库存扣减成功，添加订单信息
         VoucherOrder voucherOrder = new VoucherOrder();
         //添加订单id
         //使用订单生成器生成id
         long id = redisIdWorker.nextId("order");
         voucherOrder.setId(id);
         //添加用户id

         voucherOrder.setUserId(userId);
         //添加消费卷id
         voucherOrder.setVoucherId(voucherId);
         //添加到数据库
         boolean save = this.save(voucherOrder);
         if (!save) {
             //添加失败
             return Result.fail("下单失败");
         }
         return Result.ok(id);
    }
}

测试结果：实现了多个服务器下的一人一单

现阶段存在问题：当线程阻塞时间超过setnx的自动过期时间时可能导致一人多单和setnx的key误删情况

 优化误删问题

思路：

 实现：

修改工具类

package com.hmdp.utils;

import cn.hutool.core.lang.UUID;
import org.springframework.data.redis.core.StringRedisTemplate;

import java.util.concurrent.TimeUnit;

public class SimpleRedisLock implements ILock{

    public String name;
    public StringRedisTemplate stringRedisTemplate;

    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    private static final String KEY_PREFIX="lock:";
    private static final String ID_PREFIX= UUID.fastUUID().toString(true)+"-";



    @Override
    public boolean tryLock(long timeoutSec) {
        //获取线程标识
        String thread = ID_PREFIX+Thread.currentThread().getId();
        //获取锁
        Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFIX + name, thread , timeoutSec, TimeUnit.SECONDS);

        return Boolean.TRUE.equals(aBoolean);
    }

    @Override
    public void unlock() {
        //获取锁标识
        String thread = ID_PREFIX+Thread.currentThread().getId();
        //获取redis中的值
        String s = stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
        if (thread.equals(s)){
            //释放锁
            stringRedisTemplate.delete(KEY_PREFIX+name);
        }
    }
}

现阶段依旧存在误删除的问题

逻辑：

 解决方法：让判断锁标识与释放锁保持原子性

Lua脚本

 解决方法

1.创建nulock.lua文件

2.编写lua脚本

-- 获取锁中的线程标识 get key
local  id=redis.call('get',KEYS[1])
--比较线程标识与锁中的标识是否一致
if id == ARGV[1] then
    --释放锁
    return redis.call('del',KEYS[1])
end
return 0

3.修改unlock方法

 //创建接收lua脚本
    private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;
    //在静态方法中初始化UNLOCK_SCRIPT
    static {
        UNLOCK_SCRIPT=new DefaultRedisScript<>();
        //设置接收lua脚本文件
        UNLOCK_SCRIPT.setLocation(new ClassPathResource("nulock.lua"));
        //设置返回值类型
        UNLOCK_SCRIPT.setResultType(Long.class);
    }


    @Override
    public void unlock() {
        //使用lua脚本
        stringRedisTemplate.execute(UNLOCK_SCRIPT,
                Collections.singletonList(KEY_PREFIX + name),
                ID_PREFIX+Thread.currentThread().getId()
                );
    }

到目前为止已经可以做到生产可用

redis分布式锁的优化

需要优化的问题：不可重入，不可重试，超时释放，主从一致

 解决方法：使用redis的框架redisson实现分布式锁

 使用方法：

1.引入依赖

<!--        redis框架redisson-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.13.6</version>
        </dependency>

2.编写配置文件


@Configuration
public class RedissonConfig {

    @Bean
    public RedissonClient redissonClient(){
        //配置
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.2.182:6379").setPassword("123456");
        //创建Redissonclient对象
        return Redisson.create(config);
    }
}

3.修改业务类（仅进行注入了RedissonClient 和创建锁对象和trylock的参数）

package com.hmdp.service.impl;

import com.hmdp.dto.Result;
import com.hmdp.entity.SeckillVoucher;
import com.hmdp.entity.Voucher;
import com.hmdp.entity.VoucherOrder;
import com.hmdp.mapper.VoucherOrderMapper;
import com.hmdp.service.ISeckillVoucherService;
import com.hmdp.service.IVoucherOrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.service.IVoucherService;
import com.hmdp.utils.RedisIdWorker;
import com.hmdp.utils.SimpleRedisLock;
import com.hmdp.utils.UserHolder;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.aop.framework.AopContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.time.LocalDateTime;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 虎哥
 * @since 2021-12-22
 */
@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
   @Resource
    private ISeckillVoucherService iSeckillVoucherService;
   @Resource
   private RedisIdWorker redisIdWorker;
   @Autowired
   private StringRedisTemplate stringRedisTemplate;
    @Autowired
   private RedissonClient redissonClient;

    @Override
    public Result seckillVoucher(Long voucherId) {
        //查询优惠卷
        SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);
        //判断秒杀是否开始
        if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
            //秒杀尚未开始
            return Result.fail("秒杀尚未开始，请耐心等待");
        }
        //判断秒杀是否结束
        if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
            //秒杀已经结束
            return Result.fail("本次秒杀已经结束");
        }
        //秒杀处于正常时间段
        //判断库存是否充足
        if (voucher.getStock()<1) {
            //库存不足
            return Result.fail("本次秒杀已经被抢完");
        }
        //库存充足

        //从拦截器中获取用户id
        Long userId = UserHolder.getUser().getId();
        //对相同的id进行加锁
//        synchronized(userId.toString().intern()) {
            //获取代理对象
//            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            //在service中添加createVoucherOrder方法，也可利用idea代码修复功能自动添加
//            return proxy.createVoucherOrder(voucherId);
//            return createVoucherOrder(voucherId);
//        }

        //创建锁对象
//        SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);
        RLock lock = redissonClient.getLock("lock:order:" + userId);
        //获取锁
        boolean tryLock = lock.tryLock();

        if (!tryLock) {
            //获取锁失败
            return Result.fail("每人仅限一单");
        }
        //获取锁成功

        try {
            return createVoucherOrder(voucherId);
        } finally {
            //释放锁
            lock.unlock();
        }


    }

    @Transactional
    public  Result createVoucherOrder(Long voucherId) {
        //从拦截器中获取用户id
        Long userId = UserHolder.getUser().getId();
         /**
          * 进行判断，一人一单
          */
         int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
         if (count > 0) {
             //用户已经购买过商品
             return Result.fail("每位用户仅限购一单");
         }

         //扣减库存
         boolean update = iSeckillVoucherService.update().setSql("stock = stock - 1")
                 .eq("voucher_id", voucherId)
                 .gt("stock", 0)
                 .update();
         //判断库存扣减是否成功
         if (!update) {
             //库存扣减失败，返回信息
             return Result.fail("库存不足");
         }
         //库存扣减成功，添加订单信息
         VoucherOrder voucherOrder = new VoucherOrder();
         //添加订单id
         //使用订单生成器生成id
         long id = redisIdWorker.nextId("order");
         voucherOrder.setId(id);
         //添加用户id

         voucherOrder.setUserId(userId);
         //添加消费卷id
         voucherOrder.setVoucherId(voucherId);
         //添加到数据库
         boolean save = this.save(voucherOrder);
         if (!save) {
             //添加失败
             return Result.fail("下单失败");
         }
         return Result.ok(id);
    }
}

原理：

 

xzm_
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
全网最全-谷粒商城项目-面试总结-简历优化
成功最快的秘诀: 抱团取暖 。
09-20 28万+
该系用采用SpringCloud架构，利用SpringBoot构建应用，利用Nacos作为服务的注册、配置中心，利用OpenFeign实现与其他模块进行交互，利用Sentinel实现熔断降级和错误处理，利用Gateway作为服务网关，利用RabbitMQ实现延迟队列，利用Redis作为缓存解决读多写少的场景，利用MySQL进行持久化，利用MyBatisPlus作为持久化框架。
Seckill.rar
07-19
- 使用Lua脚本：将多个Redis操作封装到一个Lua脚本中，通过`EVAL`执行，保证整个操作的原子性。 - 分布式锁：在高并发环境下，可使用Redis的分布式锁保证操作的顺序性。 - 预生成订单：对于一些关键操作，如生成...
Redis Lua脚本实现分布式锁
xdpcxq1029的博客
02-28 1217
Lua 是一种轻量小巧的脚本语言，用标准C语言编写并以源代码形式开放， 其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。为什么要用Lua呢Redis采用单线程架构，可以保证单个命令的原子性，但是无法保证一组命令在高并发场景下的原子性。当 事务1执行删除操作时，查询到的锁值确实相等。在 事务1执行删除操作之前，锁的过期时间刚好到达，导致 Redis 自动释放了该锁。事务2获取了这个已被释放的锁。当 事务1执行删除操作时，会意外地删除掉 事务2持有的锁。
【SpringBoot】Redis Lua脚本实战指南：简单高效的构建分布式多命令原子操作、分布式锁
墩墩分墩
05-11 1064
- **轻量级**: 它用标准C语言编写并以源代码形式开放，编译后仅仅一百余K，可以很方便的嵌入别的程序里。 - 可扩展: Lua提供了非常易于使用的扩展接口和机制：由宿主语言(通常是C或C++)提供这些功能，Lua可以使用它们，就像是本来就内置的功能一样。 - **数据类型丰富**，包括`数字、字符串、布尔值、表（数组和字典的集合）等`。这些数据类型使得Lua语言能够处理各种复杂的数据结构和算法。 - 支持面向过程(procedure-oriented)编程和函数式编程(functional progra
Redis--分布式锁详解及应用
weixin_42118323的博客
03-05 1135
分布式锁，顾名思义，就是分布式系统中使用的锁，在单体应用中我们使用synchronized、ReentrantLock来解决线程时间的共享资源的访问问题，而在分布式系统中，资源贡献问题已经由线程之间的竞争演变到了进程之间的竞争，分布式锁就是接近分布式系统中多进程之间的共享资源的访问问题。多进程可见，且互斥。具备高可用，高性能，具备良好的容错性。非阻塞的模式，如果没有获取到锁，要及时返回获取锁失败。具备锁失效机制，防止死锁的发生。加锁和释放锁必须是同一个客户端。基于MySQL实现分布式锁。
redis分布式锁-Redisson分布式锁
刘皇叔说Java的博客
10-26 145
锁我们都知道，在程序中的作用就是同步工具，保证共享资源在同一时刻只能被一个线程访问，Java中的锁我们都很熟悉了，像synchronized 、Lock都是我们经常使用的，但是Java的锁只能保证单机的时候有效，分布式集群环境就无能为力了，这个时候我们就需要用到分布式锁。其实我们设想一下，是否可以给获得锁的线程，开启一个定时守护线程，每隔一段时间检查锁是否还存在，存在则对锁的过期时间延长，防止锁过期提前释放。秒杀下单、抢红包等等业务场景，都需要用到分布式锁，我们项目中经常使用Redis作为分布式锁。
黑马点评--分布式锁
weixin_53050118的博客
11-20 792
​ 分布式锁：满足分布式系统或集群模式下多进程可见并且互斥的锁。
Redis04-分布式锁
Elaine2391的博客
11-12 508
redis中的分布式锁
黑马点评-分布式锁业务
cangshanjiang的博客
03-08 1182
分布式系统部署了多个tomcat，每个tomcat都有一个属于自己的jvm，那么假设在服务器A的tomcat内部，有两个线程，这两个线程由于使用的是同一份代码，那么他们的锁对象是同一个，是可以实现互斥的，但是如果现在是服务器B的tomcat内部，又有两个线程，但是他们的锁对象写的虽然和服务器A一样，但是锁对象却不是同一个，所以线程3和线程4可以实现互斥，但是却无法和线程1和线程2实现互斥，这就是集群环境下，syn锁失效的原因，在这种情况下，我们就需要使用分布式锁来解决这个问题。
分布式锁-Redisson
qq_52922453的博客
10-09 8256
和我们本地锁⼀样互斥性是最基本，但是分布式锁需要保证在不同节点的不同线程的互斥。和本地锁⼀样⽀持锁超时，加锁成功之后设置超时时间，以防⽌线程故障导致不释放锁，防。当当前线程加锁成功之后，执⾏添加订单的过程中，如果当前线程出现异常导致⽆法释放。锁过期了，并且被其他线程成功加锁，⼀样会导致当前线程删除其他线程的锁。可重⼊锁：当在⼀个线程中第⼀次成功获取锁之后，在此线程中就可以再次获取。同⼀个节点上的同⼀个线程如果获取了锁之后那么也可以再次获取这个锁。延⻓过期时间，保证业务线程正常执⾏的过程中，锁不会过期。
redis实战-redis实现异步秒杀优化
weixin_64133130的博客
09-12 3952
当用户发起请求，此时会请求nginx，nginx会访问到tomcat，而tomcat中的程序，会进行串行操作，分成如下几个步骤1、查询优惠卷2、判断秒杀库存是否足够3、查询订单4、校验是否是一人一单5、扣减库存6、创建订单在这六步操作中，又有很多操作是要去操作数据库的，而且还是一个线程串行执行， 这样就会导致我们的程序执行的很慢。
guidijie-heima-toutiao-master_java_秒杀_
10-01
同时，为了避免并发下的数据一致性问题，可能还会利用Redis的事务或者lua脚本来保证操作的原子性。 在实际项目中，为了模拟高并发环境，可能还需要考虑压力测试。使用JMeter、LoadRunner等工具进行性能测试，评估...
Redis分布式锁实现方式及超时问题解决
08-19
解决思路是使用 Lua脚本实现多条指令的原子性执行，并对释放锁进行身份校验，使用随机数作为value的唯一标识。 七、结论 本文详细介绍了分布式锁的实现方式和超时问题解决思路，帮助读者理解分布式锁的应用场景和...
Redis实战代码演示，异步秒杀解决策略为redis stream！-RedisPractie.zip
01-30
Redis是一种高性能的键值数据库，常用于数据缓存、分布式锁、消息队列等场景。在高并发的秒杀活动中，传统的同步处理方式可能导致服务器负载过大，甚至崩溃。本实战项目利用Redis Stream作为异步秒杀的解决方案，...
分布式锁原理讲解视频资料
09-19
还可以结合lua脚本增强安全性。 3. 基于Zookeeper的分布式锁：利用Zookeeper的临时有序节点和watcher特性，实现公平锁和非公平锁。这种实现方式稳定且可扩展，但需要对Zookeeper有一定的了解。 4. 基于分布式服务...
Minos 多主机分布式 docker-compose 集群部署
wangqiaowq的博客
07-25 250
对象存储服务（Object Storage Service，OSS）是一种海量、安全、低成本、高可靠的云存储服务，适合存放任意类型的文件。容量和处理能力弹性扩展，多种存储类型供选择，全面优化存储成本。当然 Minio 除了直接作为对象存储使用，还可以作为云上对象存储服务的网关层，无缝对接到 Amazon S3、MicroSoft Azure。Minio 是个基于 Golang 编写的开源对象存储套件，虽然轻量，却拥有着不错的性能。
Gateway网关分布式微服务认证鉴权
最新发布
pscool的博客
07-25 518
（之前有使用过这种实现，定义个公共认证模块的jar包，各个微服务引入这个jar包，jar包中引入了security，开启全局校验，各个微服务可以使用注解，各个微服务可以覆盖jar包中的关键配置类实现。但是，后来遇到微服务之间互相调用时也得把这个令牌给带上去以供被调用的微服务作权限校验的问题，这样就导致权限校验管理混乱。所以还不如直接在网关层作校验，然后校验通过后，将用户身份权限写成请求头，在网关转发的时候携带给下面的微服务，后面微服务如果有必要作权限校验的话，可以使用AOP自主实现校验逻辑）
分布式文件存储行业解决方案和技术选型分析
zhuzhu_YT的博客
07-25 1681
上一集，我们已经完成了初始化测试报告以及判断压测类型的实战，我们在文章的末尾提到了文件上传的问题以及文件存储的问题，也说了接下来的几集中，我们会讨论分布式文件存储的内容。那么话不多说，我们就根据这一集的标题来展开分布式文件存储的讨论吧。成本：MinIO作为开源解决方案，可以节省成本，适合对存储成本有严格控制的场景。而云厂商解决方案需要付费，但通常提供更全面的服务和支持。自主性：使用MinIO等开源解决方案，企业可以拥有更高的自主性和控制权，而云服务则由服务提供商管理。集成性。
掌握Lua脚本：COCOS2D-x游戏开发实战教程
Lua脚本中文教程是一份针对Lua编程语言的详细指南，特别适合在COCOS2D-x游戏开发环境中应用。Lua是一种轻量级、高效的脚本语言，以其简洁易读的语法和灵活性著称。《Programming in Lua》这本书是该领域的经典之作，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值