当前位置：网站首页>下单延迟10s撤单性能测试＃yyds干货盘点＃

下单延迟10s撤单性能测试＃yyds干货盘点＃

2021-11-25 16:32:35 【FunTester】

我曾经天真以为，性能测试场景我已经无敌了，可现实又轻轻拍了我一下。

研发提出了一个下单之后延迟10s撤单的压测需求，着实让我迷糊了一会儿，最后参考了Java的延迟队列java.util.concurrent.DelayQueue实现了这个需求。

需求

在某个场景中，我之前的设计是下单，成功的话撤单，原因是为了避免测试用户资产被耗尽。

最近研发对服务功能逻辑进行了优化，在回归测试中，发现这个用例测试结果与之前差异较大。研发判断可能是下单、撤单间隔时间较短导致问题。所以需要进行延迟撤单的压测。

思路

这里使用了java.util.concurrent.DelayQueue这个线程安全队列类，看名字其实也能明白用途。还有一个方案java.util.Timer，但是会创建额外的线程，而且难以控制撤单的速率，所以这次就放弃了。

首先每次下单时候，如果成功会把订单号通过一个java.util.concurrent.Delayed实现类记录到java.util.concurrent.DelayQueue队列中，然后在com.oktest.okex.algo.trade.OrderAndCancelGrid3.FunTester#doing方法中从延迟队列中获取到期的订单号，然后进行撤单操作。

实现

订单ID是java.lang.String类型，java.util.concurrent.Delayed实现类如下：

    private static class FunDelay implements Delayed {

        int time

        String id

        FunDelay(String id) {
            this.time = getMark() + delay
            this.id = id
        }

        @Override
        public long getDelay(TimeUnit unit) {
            return time - getMark();
        }

        @Override
        public int compareTo(Delayed o) {
            FunDelay item = (FunDelay) o;
            if (this.time < item.time) {
                return -1;
            } else {
                return 1;
            }
        }
    }

     
    
      
  • 1.
    • 
      
  • 2.
    • 
      
  • 3.
    • 
      
  • 4.
    • 
      
  • 5.
    • 
      
  • 6.
    • 
      
  • 7.
    • 
      
  • 8.
    • 
      
  • 9.
    • 
      
  • 10.
    • 
      
  • 11.
    • 
      
  • 12.
    • 
      
  • 13.
    • 
      
  • 14.
    • 
      
  • 15.
    • 
      
  • 16.
    • 
      
  • 17.
    • 
      
  • 18.
    • 
      
  • 19.
    • 
      
  • 20.
    • 
      
  • 21.
    • 
      
  • 22.
    • 
      
  • 23.
    • 
      
  • 24.
    • 
      
  • 25.
    • 
      
  • 26.
    •

测试用例

大部分内容复用了之前的设计，重写了after方法，处理用户结束测试之后，延迟队列中尚未处理的订单ID。

    private static class FunTester extends FixedThread<Trade> {

        DelayQueue<FunDelay> ids = new DelayQueue<>()


        FunTester(Trade o, int limit) {
            super(o, limit, true)
        }

        @Override
        protected void doing() throws Exception {
            def res = f.order(********)
            if (0 == res.getInteger("code")) {
                def array = res.getJSONArray("data").get(0)
                def id = array.getString("Id")
                ids.add(new FunDelay(id))
            } else {
                output(res.toString())
            }
            int i = 0
            while (true) {
                if (i++ > 10) break
                def poll = ids.poll()
                if (poll == null) break
                f.stop("***", poll.id)
            }
        }

        @Override
        protected void after() {
            super.after()
            sleep(1.0)
            f.clearGrid()
        }

        @Override
        ThreadBase clone() {
            return new FunTester(f, limit)
        }


    }


     
    
      
  • 1.
    • 
      
  • 2.
    • 
      
  • 3.
    • 
      
  • 4.
    • 
      
  • 5.
    • 
      
  • 6.
    • 
      
  • 7.
    • 
      
  • 8.
    • 
      
  • 9.
    • 
      
  • 10.
    • 
      
  • 11.
    • 
      
  • 12.
    • 
      
  • 13.
    • 
      
  • 14.
    • 
      
  • 15.
    • 
      
  • 16.
    • 
      
  • 17.
    • 
      
  • 18.
    • 
      
  • 19.
    • 
      
  • 20.
    • 
      
  • 21.
    • 
      
  • 22.
    • 
      
  • 23.
    • 
      
  • 24.
    • 
      
  • 25.
    • 
      
  • 26.
    • 
      
  • 27.
    • 
      
  • 28.
    • 
      
  • 29.
    • 
      
  • 30.
    • 
      
  • 31.
    • 
      
  • 32.
    • 
      
  • 33.
    • 
      
  • 34.
    • 
      
  • 35.
    • 
      
  • 36.
    • 
      
  • 37.
    • 
      
  • 38.
    • 
      
  • 39.
    • 
      
  • 40.
    • 
      
  • 41.
    • 
      
  • 42.
    • 
      
  • 43.
    •

执行

执行方法依旧复用之前的内容，添加第4个参数，来参数化延迟的时间。


    static int delay;

    public static void main(String[] args) {
        ClientManage.init(10, 5, 0, "", 0)
        def util = new ArgsUtil(args)
        def thread = util.getIntOrdefault(0, 1)
        def times = util.getIntOrdefault(1, 1000)
        def runuptime = util.getIntOrdefault(2, 0)
        delay = util.getIntOrdefault(3, 3)
        Constant.RUNUP_TIME = runuptime
        Common.PRINT_RESPONSE = false
        Common.VERIFY = false
        FunLibrary.LOG_KEY = false
        Common.MOCO = true
        Common.setHost()
        def line = DataUtils.getMocoTokens()
        def tasks = []
        thread.times {
            def base = getBase(line.get(getRandomInt(500)))
            def drive = new Trade(base)
            tasks << new FunTester(drive, times)
        }

        new Concurrent(tasks, "下单和延迟10s撤单").start()

        over()
    }

     
    
      
  • 1.
    • 
      
  • 2.
    • 
      
  • 3.
    • 
      
  • 4.
    • 
      
  • 5.
    • 
      
  • 6.
    • 
      
  • 7.
    • 
      
  • 8.
    • 
      
  • 9.
    • 
      
  • 10.
    • 
      
  • 11.
    • 
      
  • 12.
    • 
      
  • 13.
    • 
      
  • 14.
    • 
      
  • 15.
    • 
      
  • 16.
    • 
      
  • 17.
    • 
      
  • 18.
    • 
      
  • 19.
    • 
      
  • 20.
    • 
      
  • 21.
    • 
      
  • 22.
    • 
      
  • 23.
    • 
      
  • 24.
    • 
      
  • 25.
    • 
      
  • 26.
    • 
      
  • 27.
    • 
      
  • 28.
    •

测试结果

我使用了默认延迟3s的参数。下面是执行过程中的日志截图：

下单延迟10s撤单性能测试#yyds干货盘点#_压测

图中可以看到，17s开始下单，20s开始撤单。需求完美实现！

欢迎关注FunTester，Have Fun ~ Tester ！

版权声明
本文为[FunTester]所创，转载请带上原文链接，感谢
https://blog.51cto.com/FunTester/4685957

边栏推荐

猜你喜欢

随机推荐