springboot 秒杀系统（三）百万级高并发服务间同步通讯优化

古城微笑少年丶 2023-06-22 03:26 30阅读 0赞

分布式系统的思想就是：

如果一个系统的压力过大，可以把一个服务拆分成多个服务，这个叫垂直拆分。

也可以考虑做镜像集群，负载平衡，这个叫水平拆分。

这个系统我们可以考虑垂直拆分，将订单相关的功能拆分出来。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NocmVrMTE_size_16_color_FFFFFF_t_70][]

我们将订单的逻辑拿出来，放到order-service中，通过backend来调用order-service

来创建订单。

服务：backend   接受客户端请求，判断userid是否订购过(redis判断userid存在即订购过)，判断是否有库存。

order-service  提供接口，供backend调用，创建订单，减库存。

有个问题：当我有1000个并发，同时提交到backend，并且通过了判断用户，判断库存，

这个时候就会有1000个网络请求到order-service，网络消耗很大，很多并发量大的项目都有这类问题

当然，我们可以走异步通讯，也就是消息队列，但是，有些通讯必须要走同步，必须要马上知道结果。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NocmVrMTE_size_16_color_FFFFFF_t_70 1][]

**这个时候，我们可以考虑，是否可以在order-service弄个批量创建订单的接口。**

**在消费端backend，可以做个队列，存储需要调用的数据，**

**每10MS去把队列的数据读出来组成一个批量订单数据，调用order-service的批量接口，**

**将返回的数据，对应的之前提交的每个request的task-future,这样就可以减少服务与服务之间的交互。\\**

**其实很多架构和中间件都有这种方案，有个设置 batchsize或者是limittime等，都是设置当你队列大小为多少个为一批**

**或者是多少时间段内一批，都是为了减少建立连接消耗和网络消耗**

**通俗点的意思就是 比如我一个客站送人，按照一般的做法就是，来一个人，送一个人，来一个，送一个**

**我下面的代码的意思是，我现在客站，按班次发车，一段时间发一车，一段时间发一车。**

**当然这种方法只适合那种大并发的情况，如果请求并不是很频繁，这样会适得其反了**

思路大概是这样，代码传至git上。[快速地址][Link 1]，核心代码如下：

@Component
    @Slf4j
    public class OrderService {
        /**
         * 请求包类
         */
        class Request{
            String seckillId;
            String userid;
            //每个请求一个线程观察者
            CompletableFuture<String> future;
        }
        //存请求的队列
        LinkedBlockingDeque<Request> queue = new LinkedBlockingDeque<>();
    
        public String createOrder(String seckillId,String userid) throws ExecutionException, InterruptedException {
            Request request = new Request();
            request.seckillId=seckillId;
            request.userid=userid;
    
            CompletableFuture<String> future = new CompletableFuture<>();
            request.future=future;
            //加入到请求队列
            queue.add(request);
            //返回等待，
            return future.get();
        }
    
        @Autowired
        private RemoteOrderService remoteOrderService;
        /**
         * bean初始化的时候，启动一个线程
         * 每10MS，把队列里的请求批量请求
         */
        @PostConstruct
        public void init(){
            ScheduledExecutorService scheduledExecutorService=
                    Executors.newScheduledThreadPool(1);
            scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    int size = queue.size();
                    if(size ==0){
                        return;
                    }
                    //队列里面存在数据
                    JSONArray jsonArray = new JSONArray();
                    ArrayList<Request> requests = new ArrayList<>();
                    JSONObject jsonObject;
                    Request request;
                    //取出队列，组成批量数据
                    for(int i=0;i<size;i++){
                        jsonObject=new JSONObject();
                        request = queue.poll();
                        requests.add(request);
                        jsonObject.put("seckillId",request.seckillId);
                        jsonObject.put("userid",request.userid);
                        jsonArray.add(jsonObject);
                    }
                    log.info("批量提交的大小："+jsonArray.size());
                    //调用远程创建订单的批量接口
                    JSONObject result = remoteOrderService.createOrder(jsonArray);
    
                    //正确返回
                    if(result.getString("returnCode").equals("100")){
                        for (Request request1 : requests) {
                            JSONObject jsonObject1 = result.getJSONObject("returnData");
                            //通过userid唯一取出结果并将请求的future完成触发之前的请求等待
                            String result1 = jsonObject1.getString(request1.userid);
                            request1.future.complete(result1);
                        }
                    }
                }
            },0,10,TimeUnit.MICROSECONDS);//定时任务每10毫秒调用一次
        }
    }

结果：我们可以看到，本来需要服务间调用500次，现在通过队列批量只调用了6次，大大减少了网络消耗。

我感觉这波操作很6，在大并发的情况下，大大的减少了通信消耗。是不是？

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NocmVrMTE_size_16_color_FFFFFF_t_70 2][]

其他的判断用户在redis是否购买过，减库存等代码

//判断之前userid是否购买
            if(redisTemplate.opsForValue().getAndSet(userid,1)!=null){
                return "0";
            }
            redisTemplate.opsForValue().set(userid,"1",1000L*60,TimeUnit.MICROSECONDS);
            /**
             * 从redis获取库存数，因为redis的单线程，所以也不会出现超卖现象
             */
            long num = redisTemplate.opsForValue().decrement(seckillId);
            if(num<0){
                //库存已售完
                return "0";
            }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NocmVrMTE_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191216152119970.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NocmVrMTE=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NocmVrMTE_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191216153343364.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NocmVrMTE=,size_16,color_FFFFFF,t_70
[Link 1]: https://github.com/wushu0725/seckill/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NocmVrMTE_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191216161940465.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NocmVrMTE=,size_16,color_FFFFFF,t_70