使用数据库乐观锁解决高并发秒杀问题,以及如何模拟高并发的场景,CyclicBarrier和CountDownLatch类的用法

数据库:mysql

数据库的乐观锁:一般通过数据表加version来实现,相对于悲观锁的话，更能省数据库性能,废话不多说，直接看代码

第一步：

建立数据库表：

　

　CREATE TABLE `skill_activity` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '活动id',
  `name` varchar(20) NOT NULL COMMENT '活动名称',
  `num` bigint(10) NOT NULL COMMENT '活动数量限制',
  `surplus_num` bigint(10) NOT NULL COMMENT '活动剩余数量',
  `person_limit` bigint(10) NOT NULL COMMENT '单人上传限制',
  `version` bigint(10) DEFAULT '0',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

CREATE TABLE `skill_activity_order` ( `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', 
`activity_id` bigint(20) NOT NULL COMMENT '活动id', 
`thread_id` bigint(20) NOT NULL COMMENT '线程id', 
`create_at` datetime DEFAULT NULL COMMENT '创建时间', 
`name` varchar(20) NOT NULL COMMENT '活动名称', 
`url` varchar(20) DEFAULT NULL, PRIMARY KEY (`id`),
 KEY `index_thread_id` (`thread_id`) ) ENGINE=InnoDB AUTO_INCREMENT=106338 DEFAULT CHARSET=utf8

往数据库活动表(skill_activity)插入一条数据

num:商品数量;surplus_num:商品剩余数量;person_limit:单人上传数量限制;version:版本号,解决高并发问题

具体的活动秒杀订单表(skill_activity_order)：

activity_id:就是上面活动表的id;thread_id:就是线程id,实际秒杀就是用户id,name和url就是秒杀填写的一些内容,不必关注

第二步:

java代码:

1)2个表对应的mapper.java类

public interface SkillActivityMapper {
    int deleteByPrimaryKey(Long id);

    int insert(SkillActivity record);

    int insertSelective(SkillActivity record);

    SkillActivity selectByPrimaryKey(Long id);

    int updateByPrimaryKeySelective(SkillActivity record);

    int updateByPrimaryKey(SkillActivity record);
    
    int updateSkillActivityNum(SkillActivity record);//秒杀修改剩余数量的方法
}
public interface SkillActivityOrderMapper {
    int deleteByPrimaryKey(Long id);

    int insert(SkillActivityOrder record);

    int insertSelective(SkillActivityOrder record);

    SkillActivityOrder selectByPrimaryKey(Long id);
    
    List<SkillActivityOrder> selectBythreadId(Long threadId);
    
    int updateByPrimaryKeySelective(SkillActivityOrder record);

    int updateByPrimaryKey(SkillActivityOrder record);
}

　　

2)2个类对应的mapper.xml方法就不一一写出来了,看SkillActivityMapper的updateSkillActivityNum这个方法的sql语句:

<update id="updateSkillActivityNum" parameterType="com.ouer.model.SkillActivity" >
    update skill_activity
    set 
      surplus_num = #{surplusNum,jdbcType=BIGINT},
      version = #{version,jdbcType=BIGINT}+1
    where id = #{id,jdbcType=BIGINT} and version=#{version,jdbcType=BIGINT} and surplus_num>0
  </update>

还有SkillActivityOrderMapper.selectBythreadId方法

<select id="selectBythreadId" resultMap="BaseResultMap"  >
    select 
    <include refid="Base_Column_List" />
    from skill_activity_order
    where thread_id = #{threadId,jdbcType=BIGINT}
  </select>

3)version版本号是关键,update成功会导致version加1,而其他线程如果是原先的version就无法update。

4)看一下service代码：

@Override
    public SkillActivityResponse SkillActivity(SkillActivirtReq req) {
        SkillActivityResponse skillActivityResponse=new SkillActivityResponse();
        int failNum=0;
        SkillActivity skillActivity=skillActivityMapper.selectByPrimaryKey(req.getActivityId());
        List<String> urls=req.getUrls();
        if(skillActivity.getSurplusNum()<=0){
            skillActivityResponse.setErrorMsg("活动已经结束");
            skillActivityResponse.setFailNum(urls.size());
            skillActivityResponse.setSucceed(false);
            return skillActivityResponse;
        }else{
            //先查询用户上传了多少张
            int count=skillActivityOrderMapper.selectBythreadId(req.getThreadId()).size();//查询每个用户上传了多少张
            if(count>skillActivity.getPersonLimit()){
                skillActivityResponse.setErrorMsg("已经超出上传上限,上传失败");
                skillActivityResponse.setFailNum(urls.size());
                skillActivityResponse.setSucceed(false);
                return skillActivityResponse;
            }
            
            int index=(int) (skillActivity.getPersonLimit()-count);//表示还能上传的数量
            if(urls.size()<=index){
                //都可以上传
            }else{
                //表示只能上传index张图片
                urls=urls.subList(0, index);
            }
            
            //上传订单
            for(int i=0;i<urls.size();i++){
                skillActivity= skillActivityMapper.selectByPrimaryKey(req.getActivityId());
                skillActivity.setSurplusNum(skillActivity.getSurplusNum()-1);
                if(skillActivity.getSurplusNum()<0){
                    failNum++;
                    continue;
                }
                int result=skillActivityMapper.updateSkillActivityNum(skillActivity);//这个是关键
                if(result>0){
                    //上传成功
                    SkillActivityOrder activityOrder=new SkillActivityOrder();
                    activityOrder.setActivityId(skillActivity.getId());
                    activityOrder.setCreateAt(new Date());
                    activityOrder.setName(skillActivity.getName());
                    activityOrder.setThreadId(req.getThreadId());
                    activityOrder.setUrl(urls.get(i));
                    skillActivityOrderMapper.insertSelective(activityOrder);
                }else{
                    //上传失败
                    failNum++;
                }
            }
            
            skillActivityResponse.setFailNum(failNum);
            skillActivityResponse.setSucceed(true);
            return skillActivityResponse;
        }
        
        
        
    }

5）使用spring的junit来单元测试

@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(locations={"classpath:spring/applicationContext.xml"})
public class SkillActivityServieTest {
    @Autowired
    private SkillActivityService skillActivityService;
    
    class MyRun implements Runnable{
        private CyclicBarrier barrier;
        
        private CountDownLatch countDownLatch;
        
        private Long threadId;
        
        
        
        public MyRun(CyclicBarrier barrier, CountDownLatch countDownLatch,
                Long threadId) {
            super();
            this.barrier = barrier;
            this.countDownLatch = countDownLatch;
            this.threadId = threadId;
        }



        @Override
        public void run() {
            System.err.println("线程"+threadId+"准备完毕");
            try {
                barrier.await();
                SkillActivirtReq req=new SkillActivirtReq();
                req.setActivityId(1L);
                req.setThreadId(threadId);
                req.setUrls(Lists.newArrayList("url1","url2","url3","url4","url5","url6","url7"
                        ,"url7","url8","url9","url10"));
                SkillActivityResponse skillActivityResponse= skillActivityService.SkillActivity(req);
                if(skillActivityResponse.isSucceed()){
                    System.err.println("线程:"+threadId+",failNum:"+skillActivityResponse.getFailNum());
                }else{
                    System.err.println("线程:"+threadId+",errmsg:"+skillActivityResponse.getErrorMsg());
                }
            } catch (InterruptedException | BrokenBarrierException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally{
                countDownLatch.countDown();
            }
            
        }
        
    }
    
    @Test
    public void test01() throws InterruptedException{
        CyclicBarrier barrier = new CyclicBarrier(20000);// 让20000个线程同时进行操作 调用20000次方法await() 才会让20000个线程同时执行
        CountDownLatch countDownLatch=new CountDownLatch(20000);//统计耗时
        ExecutorService executorService= Executors.newCachedThreadPool();
        long start=System.currentTimeMillis();
        for(int i=1;i<=20000;i++){
            executorService.submit(new MyRun(barrier, countDownLatch, new Long(i+"")));
        }
        executorService.shutdown();
        countDownLatch.await();
        System.err.println("耗时:"+(System.currentTimeMillis()-start)+"ms");
        try {
            Thread.sleep(Integer.MAX_VALUE); //防止线程结束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

6)运行junit

会看见20000线程同时准备完毕后才会同时去秒杀商品,这个就是CyclicBarrier的作用

然后可以看见耗时:160945ms也就是160秒多一点

7)看看数据库表：

surplus_num的数量:0,version:2000,在多运行就几次也是这个结果,通过使用数据库的乐观锁来实现高并发下的秒杀

总结:数据库的乐观锁一般使用version版本号结合业务来实现,CyclicBarrier和CountDownLatch也是高并发下常用的工具类，CyclicBarrier的作用:就是让多个线程同时去操作,

CountDownLatch一般可以用来统计总耗时,由于作者水平有限,如有不足请见谅.

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/shangxinfeng/p/8891118.html