基于Redis实现秒杀【代码为先】

最新推荐文章于 2024-05-03 05:16:20 发布
最新推荐文章于 2024-05-03 05:16:20 发布
阅读量360 收藏 3
点赞数 1
分类专栏： JUC 文章标签： redis java 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40255620/article/details/123007662
版权

基于Redis实现秒杀【代码为先】

需求

现库存某一商品存货量为100，实现每秒10000请求QPS大约为20的秒杀，并能完成正常的库存扣减，防止超卖

前置知识

  1. 了解jmeter的简单使用用于模拟并发；
  2. redis在Java语言下的基本操作；

环境说明

1、redis version 3.2
2、Maven 3.6    
3、redis的数据结构 商品编号为key 当前时间+过期时间组成的时间戳为Value 
4、Jmeter 5.4.3 项目基于springboot实现

代码结构如下

---com.liang
	---controller
	   GoosController
	---entity
	   GoodsStore
	---respository
	   GoodsStoreRespository
    ---service
        ---impl
           GoodsStoreServiceImpl
        GoodsStoreService
    ---lock
       RedisLockD

POM依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.liang</groupId>
    <artifactId>springbootRedis001</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
    </parent>
    <!--  引入各种各样的组件  -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--    jpa    -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!--  整合redis 虽说是springboot整合redis 但其实为 Spring Data Redis 操作redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--    引入连接池    -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <!--   引入lombok     -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!--fastJson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.56</version>
        </dependency>
        <!--  导入thymleaf      -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <!--   mysql     -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--   测试     -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <!--    没有该配置，devtools不生效    -->
                    <fork>true</fork>
                    <addResources>true</addResources>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

数据结构

在这里插入图片描述

Entity

package com.liang.entity;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;


import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;


/**
 * Created with Intellij IDEA
 *
 * @Auther: liangjy
 * @Date: 2022/01/07/11:14
 * @Description: 秒杀demo 连接数据库
 */
@Entity
@Table(name = "goods_store", schema = "seckill")
@Getter
@Setter
@ToString
public class GoodsStore implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    private String code;

    @Column(name = "store")
    private int store;
}

Repository代码

package com.liang.respository;

import com.liang.entity.GoodsStore;
import io.lettuce.core.dynamic.annotation.Param;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import javax.transaction.Transactional;

/**
 * Created with Intellij IDEA
 *
 * @Auther: liangjy
 * @Date: 2022/01/07/11:48
 * @Description:
 */

public interface GoodsStoreRespository extends JpaRepository<GoodsStore,String> {
    /**
     * 更新库存
     * @param code
     * @param store
     * @return
     */
    @Modifying
    @Transactional
    @Query("update GoodsStore gs set gs.store=?2 where gs.code=?1")
    int updateStore(@Param("code") String code, @Param("store")Integer store);
}

service

package com.liang.service;

import com.liang.entity.GoodsStore;

public interface GoodsStoreService {
    /**
     * 根据产品编号更新库存
     * @param code
     * @return
     */
    String updateGoodsStore(String code,int count);

    /**
     * 获取库存对象
     * @param code
     * @return
     */
    GoodsStore getGoodsStore(String code);
}
impl
package com.liang.service.impl;

import com.liang.entity.GoodsStore;
import com.liang.respository.GoodsStoreRespository;
import com.liang.rlock.RedisLockD;
import com.liang.service.GoodsStoreService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.Optional;

@Service
public class GoodsStoreServiceImpl implements GoodsStoreService {

    @Autowired
    private GoodsStoreRespository goodsStoreRespository;

    @Autowired
    private RedisLockD redisLock;

    /**
     * 超时时间 5s
     */
    private static final int TIMEOUT = 5 * 1000;

    /**
     * 根据产品编号更新库存
     *
     * @param code  商品编号
     * @param count 前端传过来的数量
     * @return
     */
    @Override
    public String updateGoodsStore(String code, int count) {
        //上锁
        BigDecimal count1 = new BigDecimal(count);
        long time = System.currentTimeMillis() + TIMEOUT;
        /**
         * 拿不到资源 那么就会等待
         */
        if (!redisLock.lock(code, String.valueOf(time))) {
            return "排队人数太多，请稍后再试.";
        }
     
        try {
            GoodsStore goodsStore = getGoodsStore(code);
            if (goodsStore != null) {
                if (goodsStore.getStore() <= 0) {
                    return "对不起，卖完了，库存为：" + goodsStore.getStore();
                }
                if (goodsStore.getStore() < count) {
                    return "对不起，库存不足，库存为：" + goodsStore.getStore() + " 您的购买数量为：" + count;
                }
                int store = goodsStore.getStore();
                BigDecimal stroe = new BigDecimal(store);
                BigDecimal remainstore = stroe.subtract(count1);
                goodsStoreRespository.updateStore(code, Integer.parseInt(String.valueOf(remainstore)));
                try {
                    //为了更好的测试多线程同时进行库存扣减，在进行数据更新之后先等1秒，让多个线程同时竞争资源
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return "恭喜您，购买成功！";
            } else {
                return "获取库存失败。";
            }
        } finally {
            //释放锁
            redisLock.release(code, String.valueOf(time))；
        }
    }

    /**
     * 获取库存对象
     *
     * @param code
     * @return
     */
    @Override
    public GoodsStore getGoodsStore(String code) {
        Optional<GoodsStore> optional = goodsStoreRespository.findById(code);
        return optional.get();
    }
}

lock

package com.liang.rlock;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

/**
 * Created with Intellij IDEA
 *
 * @Auther: liangjy
 * @Date: 2022/01/07/14:36
 * @Description:
 */
@Component
public class RedisLockD {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 加锁
     *
     * @param lockKey   加锁的Key
     * @param timeStamp 时间戳：当前时间+超时时间
     * @return
     */
    public boolean lock(String lockKey, String timeStamp) {
        /**
         * 在这个场景下商品编码作为key 时间戳来作为value setnx
         * 设置成功返回true
         */
        if (stringRedisTemplate.opsForValue().setIfAbsent(lockKey, timeStamp)) {
            // 对应setnx命令，可以成功设置,也就是key不存在，获得锁成功
            return true;
        }

        //设置失败的原因是因为这个商品已经被操作了，获得锁失败
        // 判断锁超时 - 防止原来的操作异常，没有运行解锁操作 ，防止死锁
        String currentLock = stringRedisTemplate.opsForValue().get(lockKey);
        // 如果锁过期 currentLock不为空且小于当前时间
        if (!StringUtils.isEmpty(currentLock) && Long.parseLong(currentLock) < System.currentTimeMillis()) {
            //如果lockKey对应的锁已经存在，获取上一次设置的时间戳之后并重置lockKey对应的锁的时间戳
            /**
             * getAndSet
             * 获取原来key键对应的值并重新赋新值。
             * 拿到原来的时间戳并复制新的时间戳
             * prelock 为原来的时间戳
             */
            String preLock = stringRedisTemplate.opsForValue().getAndSet(lockKey, timeStamp);

            //假设两个线程同时进来这里，因为key被占用了，而且锁过期了。
            //获取的值currentLock=A(get取的旧的值肯定是一样的),两个线程的timeStamp都是B,key都是K.锁时间已经过期了。
            //而这里面的getAndSet一次只会一个执行，也就是一个执行之后，上一个的timeStamp已经变成了B。
            //只有一个线程获取的上一个值会是A，另一个线程拿到的值是B。
            if (!StringUtils.isEmpty(preLock) && preLock.equals(currentLock)) {
                return true;
            }
        }

        return false;
    }

    /**
     * 释放锁
     *
     * @param lockKey
     * @param timeStamp
     */
    public void release(String lockKey, String timeStamp) {
        try {
            String currentValue = stringRedisTemplate.opsForValue().get(lockKey);
            if (!StringUtils.isEmpty(currentValue) && currentValue.equals(timeStamp)) {
                // 删除锁状态
                stringRedisTemplate.opsForValue().getOperations().delete(lockKey);
            }
        } catch (Exception e) {
            System.out.println("警报！警报！警报！解锁异常");
        }
    }
}

controller

package com.liang.controller;

import com.liang.service.GoodsStoreService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

/**
 * Created with Intellij IDEA
 *
 * @Auther: liangjy
 * @Date: 2022/01/07/14:42
 * @Description:
 */
@Controller
@RequestMapping("/")
public class GoosController {
    @Autowired
    private GoodsStoreService goodsStoreService;
    /**
     * 秒杀提交
     *
     * @param code
     * @param num
     * @return
     */
    @PostMapping("secKill")
    @ResponseBody
    public String secKill(@RequestParam(value = "code", required = true) String code, @RequestParam(value = "num", required = true) Integer num) {
        String reString = goodsStoreService.updateGoodsStore(code, num);
        return reString;
    }
}

执行测试

Jmeter 建立线程组

建立线程组【一秒设立10000个线程数】

在这里插入图片描述

http请求设置

在这里插入图片描述

查看结果树

在这里插入图片描述

最终效果就是一万个线程数，只有随机11个线程数秒杀成功。相当于实现了非公平锁。但在用户角度来看反而挺公平的

获得锁的时间戳：1645169458647
剩余库存：1000
扣除库存：1
释放锁的时间戳：1645169458647
获得锁的时间戳：1645169459801
剩余库存：999
扣除库存：1
释放锁的时间戳：1645169459801
获得锁的时间戳：1645169460897
剩余库存：998
扣除库存：1
获得锁的时间戳：1645169461948
释放锁的时间戳：1645169460897
剩余库存：997
扣除库存：1
释放锁的时间戳：1645169461948
获得锁的时间戳：1645169463224
剩余库存：996
扣除库存：1
获得锁的时间戳：1645169464540
释放锁的时间戳：1645169463224
剩余库存：995
扣除库存：1
释放锁的时间戳：1645169464540
获得锁的时间戳：1645169465695
剩余库存：994
扣除库存：1
释放锁的时间戳：1645169465695
获得锁的时间戳：1645169466746
剩余库存：993
扣除库存：1
获得锁的时间戳：1645169467859
释放锁的时间戳：1645169466746
剩余库存：992
扣除库存：1
释放锁的时间戳：1645169467859
获得锁的时间戳：1645169468955
剩余库存：991
扣除库存：1
释放锁的时间戳：1645169468955
获得锁的时间戳：1645169469966
剩余库存：990
扣除库存：1
释放锁的时间戳：1645169469966

查看数据库是否出现超卖

在这里插入图片描述

数据显示正常，简单实现了开篇需求

今天菜鸟就陪大家到这里了，代码注释关键部分做了解释，部分不明白可以私信聊哈~ 下次再见

附上仓库地址

进阶的菜鸟
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Redis+LUA脚本实现库存秒杀
m0_59665742的博客
07-03 471
直接上代码 private final String NO_LOCK_DECRBY_STOCK = " if tonumber(redis.call('get',KEYS[1])) >= math.abs(ARGV[1]) then\n" + " redis.call('incrby',KEYS[1],ARGV[1])\n" + " return -1\n" + " else\n
redis之：秒杀功能
我智商开挂的博客
05-21 1086
【代码】redis之：秒杀功能。
2024年最新《Redis实战篇》三、优惠券秒杀(2)
kOS0ym的博客
05-03 40
时间戳：31bit，以秒为单位，可以使用69年序列号：32bit，秒内的计数器，支持每秒产生2^32个不同ID。
Redis实现秒杀
root_zhb的博客
04-29 4195
Redis实现秒杀，并解决连接超时、超卖、库存遗留问题
Redis：原理速成+项目实战——Redis实战10（Redis消息队列实现异步秒杀）
m0_52380556的博客
01-11 1198
Redis：原理速成+项目实战——Redis实战10（Redis消息队列实现异步秒杀）
Redis队列实现Java版秒杀系统（无脚本、可用于生产）
z_ssyy的博客
06-25 723
如此，每个请求都无需经过加锁操作，直接利用redis的单线程特性，即可实现高并发下的秒杀：请求到达redis，redis会逐个执行，每一次执行要么返回一个值，要么返回null。赶工分布式秒杀，没想到如此基本的内容，竟没找到一个靠谱的实现，从上午写到现在(周末晚8点)一顿饭没吃，被网上过于demo的资源逼的，忍饿怒出此文。demo里同样没写个重试，抢不到锁就失败，醉了，不过就算写重新抢锁的机制，那么几十个上百个线程不断抢锁，想想是个挺恐怖的事，更别提高并发了。
基于redis实现高并发异步秒杀点评项目
最新发布
05-20
在本项目中，我们将探讨如何基于Redis实现一个高并发、异步的秒杀系统，以确保在流量高峰期能够稳定运行，避免传统数据库可能出现的性能瓶颈。 **一、Redis介绍** Redis是一个开源的内存数据结构存储系统，它可以...
springboot+redis 秒杀代码实现
09-21
在本文中，我们将深入探讨如何使用Spring Boot和Redis来实现一个高效的秒杀系统，以解决商品超卖和用户重复购买的问题。Spring Boot以其简洁的配置和强大的依赖注入机制，成为了现代Java开发的首选框架，而Redis作为...
基于redis的秒杀系统模拟
10-09
在构建基于Redis的秒杀系统时，我们主要关注的是如何高效、安全地处理大量并发请求，确保系统的稳定性和数据的一致性。以下是对这个话题的详细讲解： 首先，Redis作为一个高性能的键值存储系统，因其内存操作和丰富...
Redis从入门到精通(九)Redis实战(六)基于Redis队列实现异步秒杀下单 测试项目代码
04-08
**Redis入门到精通系列之九：Redis实战(六)——基于Redis队列实现异步秒杀下单测试项目代码** 在本教程中，我们将探讨如何利用Redis的队列特性来实现一个高效的异步秒杀下单系统。秒杀活动是电商、营销活动中常见的...
Redis 设计商品秒杀
湖人•总冠军
10-22 1887
前言： 最近来了一个新需求，需要开发一个商品秒杀模块，而且需求很紧急须尽快上线。 方案1： 数据库锁进行控制，获取秒杀商品数量并加锁，如果数量大于零则成功，否则秒杀失败。 @Override @Transactional public Result startkilDBPCC_ONE(long seckillId, long userId) { ...
PHP利用Redis 事务实现商品秒杀
u014225032的博客
07-21 2451
PHP实现秒杀
Redis实现秒杀功能
weixin_43486863的博客
10-23 5335
用Redis实现各种秒杀功能 前言 个人经验总结的一些观点看法，阅读了各大平台提供的关于秒杀实现的资料，总结的仅供参考，文中有写的不对的地方请指正！ 秒杀设计 一般处理秒杀有三种思路： 分布式处理 异步处理 写入内存处理 分布式处理 分布式处理就是把大量的请求分散到多个服务器上运行，一般使用hash实现均匀分布（通过支持MD5与MurmurHash两种计算方式，默认是采用MurmurHash，高效...
redis高并发秒杀测试
开发猫
11-08 6327
  项目源码：https://pan.baidu.com/s/1KfTRyghgUqvkpBCHN6xJwg 准备 使用docker-compose命令启动redis服务器（可以用其他方式启动） idea启动测试项目 jmeter测试脚本 高并发秒杀-重现超卖问题.jmx 高并发秒杀-有事务方式减少库存.jmx 重现秒杀时出现的超卖问题 核心测试代码如下： /** *...
Java秒杀实战 （五） 页面级高并发秒杀优化（Redis缓存+静态化分离）
插上小翅膀的程序猿Wings
07-24 5959
我们发现，目前系统最大的瓶颈就在数据库访问。因此，系统优化的方案核心在于减少数据库的访问，而缓存就是一个好方法。 一、页面缓存 以商品列表为例，Controller方法改造如下 @RequestMapping(value = "/to_list", produces = "text/html") @ResponseBody public String toList(HttpServl...
秒杀系统的架构设计
fallinlovelj的技术专栏
04-11 995
秒杀系统的实现
用Redis轻松实现秒杀系统
热门推荐
【良少课堂】
04-08 11万+
秒杀系统，是典型的短时大量突发访问类问题。对这类问题，有三种优化性能的思路： 写入内存而不是写入硬盘 异步处理而不是同步处理 分布式处理 用上这三招，不论秒杀时负载多大，都能轻松应对。更好的是，Redis能够满足上述三点。因此，用Redis就能轻松实现秒杀系统。 用我这个方案，无论是电商平台特价秒杀，12306火车票秒杀，都不是事:)
redis秒杀代码实现
08-18
在redis中实现秒杀有多种方式。一种常见的方式是使用分布式锁来保证只有一个线程可以执行秒杀操作。在入门版本的实现中，可以使用try{}finally{}块来确保无论业务是否抛出异常，都能执行删除redis key的操作。为了避免死锁，可以给锁设置过期时间。然而，由于时间问题，可能会出现一个锁过期后，另一个线程又将其删除的情况。为了解决这个问题，可以给每个锁加上一个唯一标识来判断是否是同一个线程删除的锁。如果担心过期时间超时，可以通过"锁续命"的方式来解决，即设置一个定时任务来检查锁是否执行完毕，如果未执行完毕，则将过期时间重置为原来的时间。释放锁的问题可以使用redissonLock.lock()方式来解决，该方法具有原子性操作。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [基于redis实现秒杀](https://blog.csdn.net/xujx321/article/details/123063796)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值