quarkus http调用负载测试结果1000个请求——16秒对65秒

Question

测试1:

@Path("/performance")
public class PerformanceTestResource {

    @Timeout(20000)
    @GET
    @Path("/resource")
    @Produces(MediaType.APPLICATION_JSON)
    public Response performanceResource() {

        final String name = Thread.currentThread().getName();
        System.out.println(name);

        Single<Data> dataSingle = null;

                try {
                    dataSingle = Single.fromCallable(() -> {
                        final String name2 = Thread.currentThread().getName();
                        System.out.println(name2);
                        Thread.sleep(1000);
                        return new Data();
                    }).subscribeOn(Schedulers.io());

                } catch (Exception ex) {
                    int a = 1;
                }

        return Response.ok().entity(dataSingle.blockingGet()).build();
    }

}

测试本身也可以看到call定期定义：

@QuarkusTest
public class PerformanceTestResourceTest {

        @Tag("load-test")
        @Test
        public void loadTest() throws InterruptedException {

            int CALL_N_TIMES = 1000;
            final long CALL_NIT_EVERY_MILLISECONDS = 10;

            final LoadTestMetricsData loadTestMetricsData = LoadTestUtils.callPeriodically(
                                                                                    this::callHttpEndpoint,
                                                                                    CALL_N_TIMES,
                                                                                    CALL_NIT_EVERY_MILLISECONDS
                                                                            );

            assertThat(loadTestMetricsData.responseList.size(), CoreMatchers.is(equalTo(Long.valueOf(CALL_N_TIMES).intValue())));

            long executionTime = loadTestMetricsData.duration.getSeconds();

            System.out.println("executionTime: " + executionTime + " seconds");

            assertThat(executionTime , allOf(greaterThanOrEqualTo(1L),lessThan(20L)));
        }

测试1的结果：

执行时间：16秒

测试2:相同，但没有@Timeout注释:

执行时间：65秒

问：为什么？我认为即使16秒也很慢。问：如何让它更快：说1000个电话要2秒。

我意识到我使用<代码>。资源中的blockingGet()，但我仍然希望重用阻塞线程。

P、 我尝试了更多的“反应式”返回＜code＞Single

更新：反应式/RX 爪哇 2 路

@path("/performance")
public class PerformanceTestResource {

//@Timeout(20000)
@GET
@Path("/resource")
@Produces(MediaType.APPLICATION_JSON)
public Single<Data> performanceResource() {

    final String name = Thread.currentThread().getName();

    System.out.println(name);
    System.out.println("name: " + name);

    return Single.fromCallable(() -> {

        final String name2 = Thread.currentThread().getName();
        System.out.println("name2: " + name2);

        Thread.sleep(1000);
        return new Data();
    });
}
}`

砰.xml：

io . small rye small rye-context-propagation-propagators-rx Java 2 org . JBoss . rest easy rest easy-rx Java 2

然后，当运行相同的测试时：

执行时间：64秒

输出将类似于：

name: vert.x-worker-thread-5 vert.x-worker-thread-9 name: vert.x-worker-thread-9 
name2: vert.x-worker-thread-9 
name2: vert.x-worker-thread-5

因此，我们阻止了工作线程，即在 REst/资源端使用。那是高速公路。然后：

如果我使用：Schedulers.io（）在睡眠-1000-call的单独执行上下文中：

return Single.fromCallable(() -> { ... }).subscribeOn(Schedulers.io());

执行时间：16秒

输出将是这样的（见一个新成员：RxCachedThreadScheduler）

name: vert.x-worker-thread-5
name2: RxCachedThreadScheduler-1683
vert.x-worker-thread-0
name: vert.x-worker-thread-0
vert.x-worker-thread-9
name: vert.x-worker-thread-9
name2: RxCachedThreadScheduler-1658
vert.x-worker-thread-8

似乎无关紧要：无论我是否显式使用block ingGet（），我都得到相同的结果。

我想，如果我不阻止它，这将是大约2-3秒。

问:从现在开始，我有办法修正/调整这个问题吗？

我假设使用＜code＞调度程序。io（）带来了＜code＞RxCachedThreadScheduler

问：或者无论如何：如何使应用程序像Quarkus一样具有响应性/反应性/性能。或者我错过了什么？

谢谢！

Answer 1

好的。也许是我。在我的call periodicly()；我传递CALL_NIT_EVERY_MILLISECONDS = 10毫秒。10 * 1000 = 10 000 -仅添加请求就需要10秒。

这个，我设置成0了

我得到了服务器1000模拟请求的6秒。

还是不是2-3秒。而是6秒。

如果我使用. getBlock并返回响应或返回单，似乎没有区别。

--

但只是提一下，这个hello world应用程序需要1秒钟来处理1000个并行请求。而Quarkus一号是6秒。

public class Sample2 {

    static final AtomicInteger atomicInteger = new AtomicInteger(0);

    public static void main(String[] args) {

        long start = System.currentTimeMillis();

        final List<Single<Response>> listOfSingles = Collections.synchronizedList(new ArrayList<>());

        for (int i=0; i< 1000; i++) {

//            try {
//                Thread.sleep(10);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }

            final Single<Response> responseSingle = longCallFunction();

            listOfSingles.add(responseSingle);

        }

        Single<Response> last = Single.merge(listOfSingles).lastElement().toSingle();

        final Response response = last.blockingGet();

        long end = System.currentTimeMillis();

        System.out.println("Execution time: " + (end - start) / 1000);

        System.out.println(response);

    }

    static Single<Response> longCallFunction() {
        return Single.fromCallable( () -> { // 1 sec
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(1000);
            int code = atomicInteger.incrementAndGet();
            //System.out.println(code);
            return new Response(code);
        }).subscribeOn(Schedulers.io());
    }

}