多线程实战---秒杀

最新推荐文章于 2024-05-16 10:27:04 发布
最新推荐文章于 2024-05-16 10:27:04 发布
阅读量1.4k 收藏 9
点赞数 3
分类专栏： 多线程 redis 文章标签： 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32527287/article/details/105878341
版权

 

最近学习多线程：

https://www.bilibili.com/video/BV1m4411u7xK/?p=74

仿着老师的思路，结合spring cloud 实现了一个简单的秒杀功能。

使用到的一些技术

1.redis 缓存

2.线程池

3.spring cloud feign  ,eureka  , config  ，定时任务 实现前后端分离

4.angularjs 

5.thymeleaf

6.mybatis逆向工程生成代码  参考别人的文档实现 

https://blog.csdn.net/qq_39056805/article/details/80585941

秒杀系统pom.xml

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.wang</groupId>
    <artifactId>seckill</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>seckill</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>

<!--        &lt;!&ndash; 缓存 &ndash;&gt;-->
<!--        <dependency>-->
<!--            <groupId>redis.clients</groupId>-->
<!--            <artifactId>jedis</artifactId>-->
<!--            <version>2.8.1</version>-->
<!--        </dependency>-->

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.28</version>
        </dependency>

        <dependency>
            <groupId>com.wang</groupId>
            <artifactId>entity</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>


        <!--        完善监控信息-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
            <version>1.5.19.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>1.5.3.RELEASE</version>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>



        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>1.5.3.RELEASE</version>
        </dependency>


        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.2</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.11</version>
        </dependency>



        <!--        eureka配置-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>

        <!--        对应config-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </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>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

秒杀系统后台项目结构

 

启动类

package com.wang.seckill;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
//开启定时任务支持
@EnableScheduling
public class SeckillApplication {

    public static void main(String[] args) {
        SpringApplication.run(SeckillApplication.class, args);
    }

}

 

controller

package com.wang.seckill.controller;


import com.fasterxml.jackson.databind.ser.std.TokenBufferSerializer;
import com.wang.blog.pojo.GoodAndUser;
import com.wang.seckill.pojo.SecKillResult;
import com.wang.seckill.pojo.TbSeckillGoods;
import com.wang.seckill.service.SeckillService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Controller
public class SeckillController {


    @Autowired
    SeckillService seckillService;


    @RequestMapping("/hello")
    @ResponseBody
    public String hello(){
        return "hello seckill";
    }

    @RequestMapping("/seckill/findAll")
    @ResponseBody
    public List<TbSeckillGoods> exeSelect(){
        List<TbSeckillGoods> list = seckillService.exeSelect();
        return list;
    }


    @RequestMapping("/select/mysql")
    @ResponseBody
    public List<TbSeckillGoods> exeSelectFromDataBase(){
        List<TbSeckillGoods> list = seckillService.exeSelectFromDataBase();
        return list;
    }

    @RequestMapping("/seckill/findOne/{id}")
    @ResponseBody
    public TbSeckillGoods findOne(@PathVariable("id") long id){
        return seckillService.findOne(id) ;
    }

    @PostMapping("/seckill/saveOrder")
    @ResponseBody
    public SecKillResult saveOrder(@RequestBody GoodAndUser goodAndUser){
        return seckillService.saveOrder(goodAndUser);
    }
}

 

 

serviceimpl

秒杀核心功能：

创建订单之前会先判断是否有订单未支付

再判断库存

都判断成功然后才使用线程池创建订单

package com.wang.seckill.service;


import com.wang.blog.pojo.GoodAndUser;
import com.wang.seckill.mapper.TbSeckillGoodsMapper;
import com.wang.seckill.pojo.SecKillResult;
import com.wang.seckill.pojo.TbSeckillGoods;
import com.wang.seckill.pojo.TbSeckillGoodsExample;
import com.wang.seckill.pojo.TbSeckillOrder;
import com.wang.seckill.thread.CreateOrderThread;
import com.wang.utils.Constant;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.client.RestTemplate;

import javax.xml.crypto.Data;
import java.util.Date;
import java.util.List;

@Service
public class SeckillServiceImpl implements  SeckillService {

    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private TbSeckillGoodsMapper tbSeckillGoodsMapper;

    @Autowired
    private IdWorker idWorker;
    @Autowired
    private ThreadPoolTaskExecutor executor;
    @Autowired
    CreateOrderThread createOrderThread;
    @Override
    public List<TbSeckillGoods> exeSelectFromDataBase() {
        TbSeckillGoodsExample example = new TbSeckillGoodsExample();
        example.createCriteria()
                .andStartTimeLessThan(new Date())
                .andEndTimeGreaterThan(new Date())
                .andStatusEqualTo("1")
                .andStockCountGreaterThan(0);
        return tbSeckillGoodsMapper.selectByExample(example);
    }

    /**
     * 同步数据库的数据到redis
     * 此处使用的定时任务，cron
     */
    @Override
    @Scheduled(cron = "0 10 08 02 05 *")
    public void synchDataToRedis() {
        TbSeckillGoodsExample example = new TbSeckillGoodsExample();
        //查询秒杀商品  当前时间在开始时间和结束时间中间
        //状态为1
        //数量大于0
        example.createCriteria()
                .andStartTimeLessThan(new Date())
                .andEndTimeGreaterThan(new Date())
                .andStatusEqualTo("1")
                .andStockCountGreaterThan(0);
        System.out.println("定时执行"+new Date());
        for (TbSeckillGoods tbSeckillGood : tbSeckillGoodsMapper.selectByExample(example)) {
//            写数据到redis
            redisTemplate.opsForHash().put(TbSeckillGoods.class.getSimpleName(),tbSeckillGood.getId(),tbSeckillGood);
            //为了解决多线程超卖问题，此处同时把商品放一份队列 因为队列里面有多少，就限制多少线程取 就不会出现超卖
             createGoodsQueue(tbSeckillGood);

        }

    }

    /**
     * 根据商品数量存一份商品信息队列
     * @param tbSeckillGood
     */
    private void createGoodsQueue(TbSeckillGoods tbSeckillGood) {
        if(tbSeckillGood.getStockCount()>0){
//            数量大于0
            for (Integer i = 0; i < tbSeckillGood.getStockCount(); i++) {
                redisTemplate.opsForList().leftPush(Constant.SECKILL_GOODS_PREFIX +tbSeckillGood.getId(),tbSeckillGood.getId());
            }
        }
    }

    /**
     * 查询所有秒杀商品
     * @return
     */
    @Override
    public List<TbSeckillGoods> exeSelect() {
        return redisTemplate.opsForHash().values(TbSeckillGoods.class.getSimpleName());
    }

    /**
     * 根据id从redis查到商品返回
     * @param id
     * @return
     */
    public TbSeckillGoods findOne(long id) {
        return (TbSeckillGoods) redisTemplate.boundHashOps(TbSeckillGoods.class.getSimpleName()).get(id);
    }

    /**
     * 这个方法解决多线程存在超卖问题
     * 并使用线程池提升效率
     * @param goodAndUser
     * @return
     */
    @Override
    public SecKillResult saveOrder(GoodAndUser goodAndUser) {


//        下订单之前，应该判断set是否有未支付的订单
        //某一个商品是否已经被该用户下过单
        if (redisTemplate.boundSetOps(Constant.SECKILL_USER_ID_PREFIX+goodAndUser.getId())
                .isMember(goodAndUser.getUserId())) {
//            是，说明该商品该用户有订单等待支付 不再创建订单直接返回
            return new SecKillResult(false,"您有未支付的订单，请先支付");
        }
        //从商品队列中判断 //        判断商品是否存在或者售完
        if (redisTemplate.boundListOps(Constant.SECKILL_GOODS_PREFIX+goodAndUser.getId())==null) {
//            售罄  不再创建订单 直接返回
            return  new SecKillResult(false,"商品已被抢完，请看看其他商品");
        }else {
//            用户信息放入用户set
            redisTemplate.boundSetOps(Constant.SECKILL_USER_ID_PREFIX+goodAndUser.getId()).add(goodAndUser.getUserId());
            //redis中放一个订单队列，存放的就是GoodAndUser信息
            redisTemplate.boundListOps(GoodAndUser.class.getSimpleName()).leftPush(goodAndUser);
            //创建订单，多线程异步执行
            executor.submit(createOrderThread);
        }
        return new SecKillResult(true,"恭喜，抢购成功，请尽快完成支付");

    }

    @Override
    public SecKillResult saveOrderForMulti(GoodAndUser goodAndUser) {
        return null;
    }


    /**
     * 这个方法多线程存在超卖问题
     *
     * @param goodAndUser
     * @return
     */
//    @Override
//    public SecKillResult saveOrder(GoodAndUser goodAndUser) {
//
        从redis获得商品数据
//        TbSeckillGoods tbSeckillGoods = findOne(goodAndUser.getId());
        判断商品是否存在或者售完
//        if (tbSeckillGoods==null || tbSeckillGoods.getStockCount()<=0) {
        是 结束
//            return  new SecKillResult(false,"商品已被抢完，请看看其他商品");
//        }else {
        否创建秒杀订单，库存是否<0  否更新redis  是存数据库，删除redis缓存 结束
//            TbSeckillOrder tbSeckillOrder = new TbSeckillOrder();
//            //idworker  id生成器，可以减少id碰撞
//            tbSeckillOrder.setSeckillId(idWorker.nextId());
//            tbSeckillOrder.setSellerId(tbSeckillGoods.getSellerId());
//            tbSeckillOrder.setCreateTime(new Date());
//            tbSeckillOrder.setMoney(tbSeckillGoods.getCostPrice());
//            tbSeckillOrder.setUserId(goodAndUser.getUserId());
//
            秒杀订单存入缓存，商品数量减一
//            redisTemplate.opsForHash().put(tbSeckillOrder.getClass().getSimpleName(),tbSeckillOrder.getUserId(),tbSeckillOrder);
//            tbSeckillGoods.setStockCount(tbSeckillGoods.getStockCount()-1);
//            if(tbSeckillGoods.getStockCount()>0){
                减完后还有商品 更新缓存
//                redisTemplate.opsForHash().put(TbSeckillGoods.class.getSimpleName(),tbSeckillGoods.getId(),tbSeckillGoods);
//            }else{
                没有商品删除缓存，更新数据库
//                redisTemplate.opsForHash().delete(tbSeckillGoods.getClass().getSimpleName(),tbSeckillGoods.getId());
//                tbSeckillGoodsMapper.updateByPrimaryKey(tbSeckillGoods);
//            }
//        }
//        return new SecKillResult(true,"恭喜，抢购成功，请尽快完成支付");
//
//    }

}

thread

package com.wang.seckill.thread;

import com.wang.blog.pojo.GoodAndUser;
import com.wang.seckill.mapper.TbSeckillGoodsMapper;
import com.wang.seckill.pojo.TbSeckillGoods;
import com.wang.seckill.pojo.TbSeckillOrder;
import com.wang.seckill.service.IdWorker;
import com.wang.utils.Constant;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.swing.border.TitledBorder;
import java.util.Date;

@Component
public class CreateOrderThread implements Runnable {

    @Autowired
    private TbSeckillGoodsMapper tbSeckillGoodsMapper;
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    IdWorker idWorker;
    @Override
    public void run() {
        //            从redis获得商品数据 goodId和userId  相当于之前已经预备待创建的订单
        GoodAndUser goodAndUser = (GoodAndUser) redisTemplate.boundListOps(GoodAndUser.class.getSimpleName()).rightPop();
        if (goodAndUser!=null) {
            TbSeckillGoods tbSeckillGoods = (TbSeckillGoods) redisTemplate.boundHashOps(TbSeckillGoods.class.getSimpleName()).get(goodAndUser.getId());
            // 创建秒杀订单，之后判断库存是否<0  否更新redis  是存数据库，删除redis缓存 结束
            TbSeckillOrder tbSeckillOrder = new TbSeckillOrder();
            //idworker  id生成器，可以减少id碰撞
            tbSeckillOrder.setSeckillId(idWorker.nextId());
            tbSeckillOrder.setSellerId(tbSeckillGoods.getSellerId());
            tbSeckillOrder.setCreateTime(new Date());
            tbSeckillOrder.setMoney(tbSeckillGoods.getCostPrice());
            tbSeckillOrder.setUserId(goodAndUser.getUserId());

//            秒杀订单存入缓存，商品数量减一  多线程，需要同步
            synchronized (TitledBorder.class){
                tbSeckillGoods = (TbSeckillGoods) redisTemplate.boundHashOps(TbSeckillGoods.class.getSimpleName()).get(goodAndUser.getId());
                redisTemplate.opsForHash().put(tbSeckillOrder.getClass().getSimpleName(),tbSeckillOrder.getUserId(),tbSeckillOrder);
                tbSeckillGoods.setStockCount(tbSeckillGoods.getStockCount()-1);
                if(tbSeckillGoods.getStockCount()>0){
//                减完后还有商品 更新缓存
                    redisTemplate.opsForHash().put(TbSeckillGoods.class.getSimpleName(),tbSeckillGoods.getId(),tbSeckillGoods);
                    redisTemplate.boundListOps(Constant.SECKILL_GOODS_PREFIX+tbSeckillGoods.getId()).rightPop();
                }else{
//                没有商品删除缓存，更新数据库
                    redisTemplate.opsForHash().delete(tbSeckillGoods.getClass().getSimpleName(),tbSeckillGoods.getId());
                    tbSeckillGoodsMapper.updateByPrimaryKey(tbSeckillGoods);
                }
            }
        }
    }
}

实体类

单独有一个module放实体类，准确的说是api   ，在这个module下面配置了entity，也有生成id，线程池等工具。

IdWorker

是一个id生成工具，避免主键冲突

ThreadPoolConfig

线程池

package com.wang.seckill.config;


import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 线程池配置
 */
@Configuration
public class ThreadPoolConfig  {
    @Bean
    RejectedExecutionHandler rejectedExecutionHandler(){
        return new ThreadPoolExecutor.CallerRunsPolicy();
    }

    @Bean("executor")
    ThreadPoolTaskExecutor threadPoolTaskExecutor(RejectedExecutionHandler rejectedExecutionHandler){
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
//        核心线程数
        threadPoolTaskExecutor.setCorePoolSize(10);
//        最大线程数 默认为Integer.MAX_VALUE
        threadPoolTaskExecutor.setMaxPoolSize(50);
//        队列的最大长度，一般需要设置值>=notifyScheduledMainExecutor.maxNum；默认为Integer.MAX_VALUE
        threadPoolTaskExecutor.setQueueCapacity(10000);
//        线程池维护线程所允许的空闲时间，默认60s
        threadPoolTaskExecutor.setKeepAliveSeconds(300);
//        线程池，无线程可用时处理策略，ThreadPoolExecutor.AbortPolicy  CallerRunsPolicy(默认)
        threadPoolTaskExecutor.setRejectedExecutionHandler(rejectedExecutionHandler);
        return threadPoolTaskExecutor;
    }
}
/*
*
*
* CallerRunsPolicy ：
这个策略重试添加当前的任务，他会自动重复调用 execute() 方法，直到成功。
AbortPolicy ：
对拒绝任务抛弃处理，并且抛出异常。
DiscardPolicy ：
对拒绝任务直接无声抛弃，没有异常信息。
DiscardOldestPolicy ：
对拒绝任务不抛弃，而是抛弃队列里面等待最久的一个线程，然后把拒绝任务加到队列。

* */

 

 

bootstrap.yml

spring:
  cloud:
    config:  #作为config客户端，从config server读配置
      name: seckillplatform   #从gitee上面读取的资源名称
      label: master
      profile: dev
      uri: http://localhost:3344   #注意这里不是直连git,不应该再出现git

主配置文件

 

测试结果：

秒杀商品展示：

 

 

redis查看结果

 

MySQL too many connections错误

Caused by: java.sql.SQLNonTransientConnectionException: Data source rejected establishment of connection,  message from server: "Too many connections"

-- 查看最大连接数

SHOW VARIABLES LIKE 'max_connections';
-- 查看线程睡眠时间
SHOW GLOBAL VARIABLES LIKE 'wait_timeout' 
-- 设置最大连接数
SET GLOBAL max_connections=1000;
-- 设置睡眠时间
SET GLOBAL wait_timeout=300; 

 

参考：https://jingyan.baidu.com/article/fc07f989c5c6bd52fee5192c.html

 

redis序列化问题

可以看到，同步到redis成功，但是数据不太看得懂：  这个不影响查询。

 

问题 写数据到redis 报错

 

org.springframework.dao.InvalidDataAccessApiUsageException: READONLY You can't write against a read only replica.; nested exception is redis.clients.jedis.exceptions.JedisDataException: READONLY You can't write against a read only replica.
这是因为我之前配置了redis的哨兵模式，此时我是用的6379端口，但是该端口已经被设置为从机，从机只能读，不能写。

package com.wang.seckill.service;


import com.wang.seckill.mapper.TbSeckillGoodsMapper;
import com.wang.seckill.pojo.TbSeckillGoods;
import com.wang.seckill.pojo.TbSeckillGoodsExample;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import javax.xml.crypto.Data;
import java.util.Date;

@Service
public class SeckillServiceImpl implements  SeckillService {

    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private TbSeckillGoodsMapper tbSeckillGoodsMapper;

    @Override
    @Scheduled(cron = "0/10 * * * * *")
    public void synchDataToRedis() {
        TbSeckillGoodsExample example = new TbSeckillGoodsExample();
        example.createCriteria()
                .andStartTimeLessThan(new Date())
                .andEndTimeGreaterThan(new Date())
                .andStatusEqualTo("1")
                .andStockCountGreaterThan(0);
        System.out.println("定时执行"+new Date());
        for (TbSeckillGoods tbSeckillGood : tbSeckillGoodsMapper.selectByExample(example)) {
//            写数据到redis
            redisTemplate.opsForHash().put("SeckillGoods",tbSeckillGood.getId(),tbSeckillGood);
        }

    }
}

 

改变自己2022
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
〖Python 数据库开发实战 - Python与Redis交互篇⑨〗- 利用 redis-py 实现模拟商品秒杀活动案例
易编橙 · 终身成长社群，相遇已是上上签！
10-02 3万+
该章节我们将要来实现一个 "模拟商品秒杀活动" 的案例，该案例在上一章节的 "缓缓存观众投票数据信息" 的案例讲更更增加了一些难度，话不多说接下来就看看案例的具体要求是什么吧。
java 多线程秒杀_【IDEA+SpringBoot+Java商城秒杀实战20】高并发秒杀接口优化
weixin_29149577的博客
02-16 531
高并发秒杀接口优化接口优化(核心思路：减少对数据库的访问)Redis预减库存减少对数据库的访问内存标记减少Redis的访问请求先入队缓冲，异步下单，增强用户体验RabbitMQ安装与SpringBoot的集成(目的：同步下单改成异步下单)Nginx水平拓展压测项目迭代是一个优化和调整的过程，发现问题解决问题，不断优化。秒杀业务场景，并发量很大，瓶颈在数据库，怎么解决，加缓存。用户发起请求时，从浏览...
最全多线程四大经典案例及java多线程的实现_java 多线程经典案例，2024年最新简直无敌
2401_84976040的博客
05-16 399
if(curTime
实战篇--优惠券秒杀
xcxcxcxx1的博客
04-29 482
利用set nx ex获取锁，并设置过期时间，保存线程标示释放锁时先判断线程标示是否与自己一致，一致则删除锁利用set nx满足互斥性利用set ex保证故障时锁依然能释放，避免死锁，提高安全性利用Redis集群保证高可用和高并发特性秒杀业务的优化思路是什么？先利用Redis完成库存余量、一人一单判断，完成抢单业务再将下单业务放入阻塞队列，利用独立线程异步下单基于阻塞队列的异步秒杀存在哪些问题？内存限制问题数据安全问题。
黑马redis实战-优惠券秒杀
qq_43156556的博客
04-11 2299
视频地址 1. 全局唯一 ID 1. 1 问题：针对优惠券秒杀模块全局唯一 ID 的作用是什么？ 作为优惠券订单 id 1.2 问题：为什么不使用数据库自增 ID ？ 考虑分布式场景下ID的全局唯一性 分库分表后，id主键如何处理 ① 数据库自增 id：先从一个数据库表中获取自增id，再根据该 id 往对应的分库分表中写入 问题：生成id的数据库表高并发瓶颈 适用场景：并发不高，数据量太大导致的分库分表 ② uuid：UUID.randomUUID() 问题：不适用于实际的业务需求，生成的订单号UUID字
分布式秒杀 - 实战
架构师尼恩
01-05 2337
疯狂创客圈 Java 高并发【 亿级流量聊天室实战】实战系列之15 【博客园总入口 】 前言 疯狂创客圈（笔者尼恩创建的高并发研习社群）Springcloud 高并发系列文章，将为大家介绍三个版本的 高并发秒杀： 一、版本1 ：springcloud + zookeeper 秒杀 二、版本2 ：springcloud + redis 分布式锁秒杀 三、版本3 ：springcloud + Ngi...
Redis实战篇--优惠券秒杀
qq_51729037的博客
02-28 246
分布式锁
redis实战-redis实现异步秒杀优化
weixin_64133130的博客
09-12 3959
当用户发起请求，此时会请求nginx，nginx会访问到tomcat，而tomcat中的程序，会进行串行操作，分成如下几个步骤1、查询优惠卷2、判断秒杀库存是否足够3、查询订单4、校验是否是一人一单5、扣减库存6、创建订单在这六步操作中，又有很多操作是要去操作数据库的，而且还是一个线程串行执行， 这样就会导致我们的程序执行的很慢。
redis实战-黑马点评-优惠卷秒杀
m0_71894372的博客
03-19 447
以上方案的失败率高，当100个线程查询到stock为100,然后一个线程修改了stock，其他线程就全部失败，因此需要改为，当stock>0即可。全局ID生成器：是一种再分布式系统下生成全局唯一的ID的工具。唯一性，高可用，高性能，安全性，递增性。修改sql语句为，使用CAS方式实现乐观锁。在更新库存时查询库存是否已经被修改。
Redis实战篇--秒杀优化（异步秒杀）
qq_51729037的博客
03-02 426
Redis 秒杀优化 消息队列
秒杀多线程
06-14
### 秒杀多线程：深入理解PV操作与多线程同步 在计算机科学领域，尤其是在操作系统和多线程编程中，同步与互斥是确保数据一致性和避免竞态条件的关键概念。**PV操作**，作为实现这些目标的重要工具，自1962年由荷兰...
CSDN-大佬JAVA开发简历.doc
01-08
他在JAVA语言方面有深厚的基础，熟练掌握语法和多线程处理，对JVM原理有一定理解，包括内存模型和垃圾回收机制。在分布式系统领域，敖丙精通Redis集群的搭建与备份策略，能应对高并发下的缓存问题。他还熟悉RocketMQ...
秒杀项目实战 ｜Golang - Redis - RocketMQ-seckill.zip
01-30
在这个项目实战中，我们关注的是如何利用Golang、Redis和RocketMQ这三个技术来构建一个稳定、高效的秒杀系统。下面将详细介绍这三个关键技术在秒杀项目中的应用。 首先，Golang作为主开发语言，其特性非常适合处理...
秒杀系统视频：第5章 秒杀压测-Jmeter压力测试
01-08
本章视频课程主要聚焦在秒杀系统的压力测试上，使用了Java技术栈以及JMeter工具进行实战演示。JMeter是一款开源、跨平台的负载和性能测试工具，广泛应用于Web应用的压力测试，可以模拟多用户并发，帮助我们评估系统...
深入理解高并发编程-核心技术原理
03-14
总的来说，这本书全面覆盖了高并发编程中的关键知识点，包括多线程原理、线程池实现、并发控制、分布式系统架构以及面试技巧，适合有志于提升并发编程能力的后端开发者阅读，尤其是对分布式锁和Java并发编程感兴趣的...
FLY（数据迁移工具） 官方部署操作手册4.9 2022.05月版本
08-05
https://cdn.avepoint.com/pdfs/ape/FLY_Installation_Guide_zh-cn_v
[毕业设计]Java多媒体租赁店管理系统设计与实现(源代码+论文).zip
08-05
[毕业设计]Java多媒体租赁店管理系统设计与实现(源代码+论文)
[java毕业作品]VB.NET+Access电表数据可视化分析系统(源代码+论文)
最新发布
08-05
[java毕业作品]VB.NET+Access电表数据可视化分析系统(源代码+论文)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值