java高并发秒杀活动的各种简单实现【springBoot+mybatis+redis+mysql】

最近遇到比较多数据不一致的问题，大多数都是因为并发请求时，没及时处理的原因，故用一个比较有代表性的业务场景【活动秒杀】来模拟一下这个这种高并发所产生的问题。

众所周知，电商系统的秒杀活动是高并发的很好应用场景，这里用的demo模拟的基本框架是springBoot+mybatis+redis+mysql，搭建的过程，我这里就不提了，有需要的可以自行百度。

1.搭好的项目目录：

2.建了一张表（记录商品名称、本次可秒杀的库存量）：

加了一条记录（后面每次测试都先手动把库存恢复成100才进行测试）

3.实体：

package com.mybatis.model;

public class MiaoShaGoods {
    private Integer id;

    private String goodsName;

    private Integer goodsSum;

    private Integer version;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getGoodsName() {
        return goodsName;
    }

    public void setGoodsName(String goodsName) {
        this.goodsName = goodsName == null ? null : goodsName.trim();
    }

    public Integer getGoodsSum() {
        return goodsSum;
    }

    public void setGoodsSum(Integer goodsSum) {
        this.goodsSum = goodsSum;
    }

    public Integer getVersion() {
        return version;
    }

    public void setVersion(Integer version) {
        this.version = version;
    }
}

 

一、不做任何处理的高并发秒杀实现（错误演示）：

1.Controller层，模拟500个并发调用：

package com.mybatis.controller;

import com.mybatis.domain.BaseResponse;
import com.mybatis.domain.MiaoshaRequest;
import com.mybatis.service.MiaoshaService;
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.*;



@Controller
@RequestMapping(value="/miaoshagoods")
public class MiaoshaController {

    @Autowired
    public MiaoshaService miaoshaService;


    @PostMapping("/miaosha_java_sql_lock")
    public @ResponseBody BaseResponse miaoshaJavaSqlLock(@RequestBody MiaoshaRequest request){

        BaseResponse response=new BaseResponse();
            for(int i=0;i<500;i++){
                Thread thread=new Thread(new Runnable() {
                    @Override
                    public void run() {
                        //不做任何处理的秒杀实现
                        miaoshaService.miaoshaGoods(request,response);              
                    }
                });
                thread.start();
            }
            return response;
     }
}

2.Service层，每个请求进来就去数据库里查剩余的库存量，并且抢购成功后，就减1个库存：

package com.mybatis.service.Impl;

import com.mybatis.dao.MiaoShaGoodsDao;
import com.mybatis.domain.BaseResponse;
import com.mybatis.domain.MiaoshaRequest;
import com.mybatis.model.MiaoShaGoods;
import com.mybatis.service.MiaoshaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


@Service
public class MiashaServiceImpl implements MiaoshaService{

    @Autowired
    MiaoShaGoodsDao miaoShaGoodsDao;

    private Lock lock = new ReentrantLock();

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    /**
     * 不做任何处理的秒杀实现
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods(MiaoshaRequest request, BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        return response;
    }
}

3.dao层（mybatis的xml文件）：

  <select id="getGoods" parameterType="java.lang.String" resultMap="BaseResultMap">
    select
    <include refid="Base_Column_List" />
    from miao_sha_goods
    where goods_name = #{goodsName,jdbcType=VARCHAR}
  </select>

  <update id="updateMsGoods" parameterType="com.mybatis.model.MiaoShaGoods">
    update miao_sha_goods
    set goods_sum = #{goodsSum,jdbcType=INTEGER}
    where goods_name = #{goodsName,jdbcType=VARCHAR}
  </update>

4.测试结果：

截图表明，居然有500个人抢购成功，而且库存量却只减少了12个，这是明显是错误的。

 

二、数据库乐观锁处理的高并发秒杀实现：

1.Controller层，模拟500个并发调用：

package com.mybatis.controller;

import com.mybatis.domain.BaseResponse;
import com.mybatis.domain.MiaoshaRequest;
import com.mybatis.service.MiaoshaService;
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.*;


@Controller
@RequestMapping(value="/miaoshagoods")
public class MiaoshaController {

    @Autowired
    public MiaoshaService miaoshaService;

    @PostMapping("/miaosha_java_sql_lock")
    public @ResponseBody BaseResponse miaoshaJavaSqlLock(@RequestBody MiaoshaRequest request){

        BaseResponse response=new BaseResponse();
        for(int i=0;i<500;i++){
            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {

                    //不做任何处理的秒杀实现
                    //miaoshaService.miaoshaGoods(request,response);
                    //数据库乐观锁秒杀
                    miaoshaService.miaoshaGoods_sql_optimistic_lock(request,response);

                }
            });
            thread.start();
        }
        return response;
    }
}

2.Service层，每个请求进来就去数据库里查剩余的库存量，并且抢购成功后，就减1个库存：

package com.mybatis.service.Impl;

import com.mybatis.dao.MiaoShaGoodsDao;
import com.mybatis.domain.BaseResponse;
import com.mybatis.domain.MiaoshaRequest;
import com.mybatis.model.MiaoShaGoods;
import com.mybatis.service.MiaoshaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


@Service
public class MiashaServiceImpl implements Miaos