java高并发秒杀活动的各种简单实现

已于 2022-10-31 10:17:10 修改
阅读量5.3k 收藏 54
点赞数 9
文章标签： java
于 2020-03-24 12:01:03 首次发布
原文链接：https://blog.csdn.net/Ouyzc/article/details/88424601
版权

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

众所周知，电商系统的秒杀活动是高并发的很好应用场景，这里用的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 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;
    }
    /**
     * 数据库乐观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_sql_optimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_lgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_lgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
 
            //做出相应的逻辑（记录抢购成功的用户名什么的....）
 
        }else{
            System.out.println("抢到iphoneX,失败！");
 
            //重试或者返回友好的提示什么的....
        }
        return response;
    }
}

3.dao层（mybatis的xml文件）[在SQL层面改为数据库乐观锁]： 

<select id="getGoods_lgs" 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_lgs" parameterType="com.mybatis.model.MiaoShaGoods">
    update miao_sha_goods
    set goods_sum = #{goodsSum,jdbcType=INTEGER},version=version+1
    where goods_name = #{goodsName,jdbcType=VARCHAR} and version = #{version,jdbcType=VARCHAR}
  </update>

4.测试结果：

截图表明，总共有500个人抢，有29个人抢购成功，而且库存量减少了29个，这保证了库存的正确性。但却会有抢购不成功的请求，需要我们后续去处理。

 

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

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);
                    //数据库悲观锁秒杀
                    miaoshaService.miaoshaGoods_sql_pessimistic_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 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;
    }
    /**
     * 数据库乐观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_sql_optimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_lgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_lgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
 
            //做出相应的逻辑（记录抢购成功的用户名什么的....）
 
        }else{
            System.out.println("抢到iphoneX,失败！");
 
            //重试或者返回友好的提示什么的....
        }
        return response;
    }
    /**
     * 数据库悲观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    @Transactional
    public BaseResponse miaoshaGoods_sql_pessimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_bgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_bgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        return response;
    }
}

 3.dao层（mybatis的xml文件）[在SQL层面改为数据库悲观锁]： 

<select id="getGoods_bgs" parameterType="java.lang.String" resultMap="BaseResultMap">
    select
    <include refid="Base_Column_List" />
    from miao_sha_goods
    where goods_name = #{goodsName,jdbcType=VARCHAR} FOR UPDATE
  </select>
 
  <update id="updateMsGoods_bgs" parameterType="com.mybatis.model.MiaoShaGoods">
    update miao_sha_goods
    set goods_sum = #{goodsSum,jdbcType=INTEGER}
    where goods_name = #{goodsName,jdbcType=VARCHAR}
  </update>

4.测试结果：

 截图表明，总共有500个人抢，有100个人抢购成功，而且库存量减少了100个，这保证了库存的正确性。

 

四、java线程同步锁处理的高并发秒杀实现：

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);
                    //数据库悲观锁秒杀
                    //miaoshaService.miaoshaGoods_sql_pessimistic_lock(request,response);
                    //java线程同步锁秒杀
                    miaoshaService.miaoshaGoods_java_synchronized_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 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;
    }
    /**
     * 数据库乐观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_sql_optimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_lgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_lgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
 
            //做出相应的逻辑（记录抢购成功的用户名什么的....）
 
        }else{
            System.out.println("抢到iphoneX,失败！");
 
            //重试或者返回友好的提示什么的....
        }
        return response;
    }
    /**
     * 数据库悲观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    @Transactional
    public BaseResponse miaoshaGoods_sql_pessimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_bgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_bgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        return response;
    }
    /**
     * java同步锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_java_synchronized_lock(MiaoshaRequest request,BaseResponse response) {
        synchronized(this){
            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个人抢，有100个人抢购成功，而且库存量减少了100个，这保证了库存的正确性。

 

五、java线程可重入锁处理的高并发秒杀实现：

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);
                    //数据库悲观锁秒杀
                    //miaoshaService.miaoshaGoods_sql_pessimistic_lock(request,response);
                    //java线程同步锁秒杀
                  //miaoshaService.miaoshaGoods_java_synchronized_lock(request,response);
                    //java线程可重入锁秒杀
                    miaoshaService.miaoshaGoods_java_reentrant_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 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;
    }
    /**
     * 数据库乐观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_sql_optimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_lgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_lgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
 
            //做出相应的逻辑（记录抢购成功的用户名什么的....）
 
        }else{
            System.out.println("抢到iphoneX,失败！");
 
            //重试或者返回友好的提示什么的....
        }
        return response;
    }
    /**
     * 数据库悲观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    @Transactional
    public BaseResponse miaoshaGoods_sql_pessimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_bgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_bgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        return response;
    }
    /**
     * java同步锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_java_synchronized_lock(MiaoshaRequest request,BaseResponse response) {
        synchronized(this){
            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;
    }
    /**
     * java可重入锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_java_reentrant_lock(MiaoshaRequest request,BaseResponse response) {
 
        lock.lock();
        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(request.getGoodNames()+"抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        lock.unlock();
        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个人抢，有100个人抢购成功，而且库存量减少了100个，这保证了库存的正确性。

 

六、redis单线程处理的高并发秒杀实现（推荐）：

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;
 
    @Autowired
    private RedisTemplate<String,String> redisTemplate;
 
 
    @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);
                    //数据库悲观锁秒杀
                    //miaoshaService.miaoshaGoods_sql_pessimistic_lock(request,response);
                    //java线程同步锁秒杀
                    //miaoshaService.miaoshaGoods_java_synchronized_lock(request,response);
                    //java线程可重入锁秒杀
                    miaoshaService.miaoshaGoods_java_reentrant_lock(request,response);
                }
            });
            thread.start();
        }
        return response;
    }
 
   @PostMapping("/miaosha_redis_lock")
    public @ResponseBody BaseResponse miaoshaRedisLock(@RequestBody MiaoshaRequest request){
        BaseResponse response=new BaseResponse();
        //初始化商品数量
        Integer goodsSum=miaoshaService.getGoodsSum(request);
        redisTemplate.opsForValue().set(request.getGoodNames()+":goodsSum",goodsSum+"");
        System.out.println("总共的库存量："+goodsSum);
 
        for(int i=0;i<500;i++){
            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {
                    miaoshaService.miaoshaGoods_redis(request,response);
                }
            });
            thread.start();
        }
        return response;
    }
}

2.Service层，先把参与秒杀的总库存量写入redis里，然后再利用redis的增量方法去递减：

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;
    }
    /**
     * 数据库乐观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_sql_optimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_lgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_lgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
 
            //做出相应的逻辑（记录抢购成功的用户名什么的....）
 
        }else{
            System.out.println("抢到iphoneX,失败！");
 
            //重试或者返回友好的提示什么的....
        }
        return response;
    }
    /**
     * 数据库悲观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    @Transactional
    public BaseResponse miaoshaGoods_sql_pessimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_bgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_bgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        return response;
    }
    /**
     * java同步锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_java_synchronized_lock(MiaoshaRequest request,BaseResponse response) {
        synchronized(this){
            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;
    }
    /**
     * java可重入锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_java_reentrant_lock(MiaoshaRequest request,BaseResponse response) {
 
        lock.lock();
        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(request.getGoodNames()+"抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        lock.unlock();
        return response;
    }
 
    @Override
    public Integer getGoodsSum(MiaoshaRequest request) {
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods(request.getGoodNames());
        return miaoShaGoods.getGoodsSum();
    }
    /**
     * redis实现秒杀
     * @param response
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_redis(MiaoshaRequest request,BaseResponse response) {
 
        //增量计算剩余库存(利用redis的单线程特性)
        double goodsSurplusSum=redisTemplate.opsForValue().increment(request.getGoodNames()+":goodsSum",-1);
        if(goodsSurplusSum>=0){
            System.out.println("抢到iphoneX,成功！还剩下："+goodsSurplusSum);
        }else {
            System.out.println("抢到iphoneX,失败！");
        }
        return response;
    }
}

3.测试结果：

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

截图表明，总共有500个人抢，有100个人抢购成功，而且库存量减少了100个，这保证了库存的正确性，抢后redis显示是-400个，说明有500个人进来了，有400个人抢不到。

综上所述，要控制库存量，一般要用锁机制。但是一般加锁的话会比较影响性能（只能用于单服务），推荐大家使用redis自带的线程安全属性来实现（可实现分布式锁）。

吴优秀
关注
  • 9
    点赞
  • 踩
  • 54
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
java高并发秒杀活动的各种简单实现【springBoot+mybatis+redis+mysql】
Ouyzc的博客
03-13 4574
最近遇到比较多数据不一致的问题，大多数都是因为并发请求时，没及时处理的原因，故用一个比较有代表性的业务场景【活动秒杀】来模拟一下这个这种高并发所产生的问题。 众所周知，电商系统的秒杀活动是高并发的很好应用场景，这里用的demo模拟的基本框架是springBoot+mybatis+redis+mysql，搭建的过程，我这里就不提了，有需要的可以自行百度。 1.搭好的项目目录： 2.建了一张...
【Java】如何设计一个秒杀系统
java_y_y的博客
06-17 1436
说起秒杀，我想你肯定不陌生，这两年，从双十一购物到春节抢红包，再到12306抢火车票，“秒杀”的场景处处可见。简单来说，秒杀就是在同一个时刻有大量的请求争抢购买同一个商品并完成交易的过程，用技术的行话来说就是大量的并发读和并发写。不管是哪一门语言，并发都是程序员们最为头疼的部分。同样，对于一个软件而言也是这样，你可以很快增删改查做出一个秒杀系统，但是要让它支持高并发访问就没那么容易了。比如说，如何让系统面对百万级的请求流量不出故障？如何保证高并发情况下数据的一致性写？完全靠堆服务器来解决吗？
Java项目利用Redisson实现真正生产可用高并发秒杀功能 支持分布式高并发秒杀
03-16 1505
Redisson真正高并发秒杀功能。Java中的高并发秒杀场景下我们可以使用redisson来实现高并发秒杀功能, 以下就是一个可用于生产环境的高并发秒杀示例代码:
Java高并发秒杀项目
nageaixiaodenanhai的博客
04-09 1099
Java高并发秒杀项目 项目代码见github，欢迎issue、fork、star。 项目实现 项目运行环境：Win10+Ubuntu18.04虚拟机，JDK1.8 项目中使用了关系型数据库MySQL（5.7.29）和非关系型数据库Redis（4.0.2），中间件RabbitMQ，因此在运行前需要将他们安装好，这三个都安装在Ubuntu系统中。 Mysql安装步骤 数据库表生成见gi...
Java 实现高并发秒杀
热门推荐
程序员学习圈
08-20 5万+
1 需求分析和技术难点： 1.1 分析：      秒杀的时候：减少库存和购买记录明细两个事件保持在同一个事物中。      使用联合查询避免同一用户多次秒杀同一商品（利用在插入购物明细表中的秒杀id和用户的唯一标识来避免）。 1.2 秒杀难点:事务和行级锁的处理 1.3 实现那些秒杀系统(以天猫的秒杀系统为例) 1....
SpringBoot、Redis轻松实现Java高并发秒杀系统笔记
今天你学Java了吗
09-13 2221
优极限【完整项目实战】半天带你用-springBoot、Redis轻松实现Java高并发秒杀系统项目笔记附带大厂面试常考秒杀问题
Springboot实现高并发秒杀系统
jerryyang_2017的博客
12-27 3455
Springboot实现高并发秒杀系统 java 高并发 springboot redis zookeeper
实现高并发秒杀的几种方式
Venus's Blog
05-23 2万+
如果要完美解决高并发场景，需要 从缓存、限流、消息队列、数据库扩展多方面考虑,而不仅仅是一两个技术就可以。还需要注意系统的稳定性、扩展性,要足够灵活与健壮。如果大家对相关文章感兴趣，可以关注公众号"架构殿堂"，会持续更新AIGC，java基础面试题, netty, spring boot,spring cloud等系列文章，一系列干货随时送达!
Redis分段锁实现超高并发秒杀
Cheney的博客
06-05 1417
超高并发秒杀—Redis分段锁！
SpringBoot+Redis实现实现Java高并发之秒杀系统
qq_44680160的博客
12-25 5254
基于SpringBoot +J ava实现高并发之秒杀系统Demo
java高并发秒杀系统.rar
09-16
在java包下面的seckill包下，创建controller，service，pojo，mapper包，在service包下创建impl包 在resource包下创建mapper包，放置mapper文件 其中templates包下放置前端页面 4.测试 ①在启动类中添加注解：@...
简单实现Java高并发之秒杀系统
03-14
秒杀系统是一种针对高并发场景下的抢购活动设计的系统，旨在克服大量用户同时访问和购买同一商品的挑战。以下是秒杀系统的概念描述： 1. **限流与并发控制**：秒杀系统需要通过限制每秒钟的请求数量或者设置并发...
基于SpringBoot实现Java高并发之秒杀系统.zip
03-23
基于SpringBoot实现Java高并发之秒杀系统 技术栈 后端： SpringBoot-2.x + Redis-4.x 前端： Bootstrap + Jquery 测试环境 IDEA + Maven-10.13 + Tomcat8 + JDK8 启动说明 启动前，请配置好 application.yml ...
SSM实战项目-Java高并发秒杀API
05-12
SSM实战项目——Java高并发秒杀API 何为秒杀？ 所谓“秒杀”，就是网络卖家发布一些超低价格的商品，所有买家在同一时间网上抢购的一种销售方式。由于商品价格低廉，往往一上架就被抢购一空，有时只用一秒钟。 ...
基于SpringBoot2.x 实现的Java高并发的秒杀系统
06-13
**基于SpringBoot实现Java高并发之秒杀系统** 项目经过严格测试，确保可以运行！源码无需做任何更改！ **技术栈** * 后端： SpringBoot-2.x + Redis-4.x * 前端： Bootstrap + Jquery **测试环境** * IDEA + ...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1263
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
golang 接口
m0_70982551的博客
07-24 811
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 366
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
java 高并发场景
06-21
Java 在高并发场景中被广泛应用，因为它的多线程和并发处理机制能够有效管理大量请求。在高并发环境中，Java主要应用了以下几个关键概念和技术： 1. **多线程**：Java 提供了强大的 `Thread` 类和 `java.util.concurrent` 包中的并发工具类（如 `ExecutorService`, `Future`, `CountDownLatch` 等），允许创建和管理多个独立执行的任务。 2. **线程池**：`ThreadPoolExecutor` 是一个核心组件，用于管理和调度线程，可以提高资源利用率并避免频繁创建和销毁线程导致的性能开销。 3. **同步与互斥**：使用 `synchronized`, `Lock` 和 `ReentrantLock` 等机制确保多个线程对共享资源的安全访问，防止数据不一致性。 4. **并发集合类**：`ConcurrentHashMap`, `CopyOnWriteArrayList` 等提供了线程安全的集合操作，支持高效的并发读写。 5. **阻塞队列**：`BlockingQueue` 类如 `ArrayBlockingQueue` 和 `LinkedBlockingQueue` 可以在高并发场景下实现任务的缓冲和调度。 6. **非阻塞I/O**：Java NIO (New I/O) 和 Netty 等框架提供异步非阻塞I/O操作，降低系统阻塞，提高网络通信效率。 7. **并发容器**：`ForkJoinPool` 和 `CompletableFuture` 适用于计算密集型任务的并行化处理。 8. **分布式系统**：Java 还广泛用于构建分布式系统，如使用 Hazelcast 或 Apache Ignite 进行内存数据缓存和分布计算。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值