是否有可能获得高吞吐量（4-5 TPS）的IO密集型服务在Java与可完成的未来或NodeJs是更好的选择

Question

我们要求开发一种能够处理大容量（约5TPS）的服务。我们必须做3-4个并行的下游Rest呼叫（下面提到的是有2个Rest呼叫的POC）-

我试图使用Completable future to do async rest调用和join方法来实现它，以聚合如下响应：{ResponseWrapper response=null；

    CompletableFuture<Student> s = CompletableFuture.supplyAsync(() -> {
                return studentService.getStudentDetails(requestContext, id, name, correlationId);
            },pool

    ).exceptionally(ex -> {
                log.error("Something went wrong in devicedm: ", ex);
                Student wrapper = new Student();
                wrapper.setStatus("500");
                Errors err = new Errors();
                err.setDescription(ex.getCause().toString());
                wrapper.setError(err);
                return wrapper;
            }

    );

    CompletableFuture<Employee> s1 = CompletableFuture.supplyAsync(() -> {
                return employeeService.getEmployeeDetails(requestContext, id, name, correlationId);
            },pool

    ).exceptionally(ex -> {
                log.error("Something went wrong in Employee: ", ex);
                Employee wrapper = new Employee();
                wrapper.setStatus(500);
                Errors err = new Errors();
                err.setDescription(ex.getCause().toString());
                wrapper.setError(err);
                return wrapper;
            }

    );

    CompletableFuture<ResponseWrapper> combinedDataCompletionStage = CompletableFuture.allOf(s, s1)
            .thenApply(ignoredVoid -> combine(s.join(), s1.join()));

    try {
        response = combinedDataCompletionStage.get();
    } catch (InterruptedException | ExecutionException e) {
        Errors error = new Errors();
        error.setDescription(e.getCause().toString());
        response.setError(error);
    }

    private ResponseWrapper combine(Student s, Employee s1) {
    ResponseWrapper response = new ResponseWrapper();

    response.setStudentInfo(s);
    response.setEmployeeInfo(s1);
    return response;
}

}

所以，我们需要帮助理解，当我们使用completable future并可用于处理其他请求时，rest调用完成后，两个线程s和s1是否会被释放？

join方法的行为是什么，从java文档来看，它似乎会等待s和s1返回响应，然后执行join操作。这是拦截电话吗？

一旦我们聚合了响应，我们必须得到调用，然后返回给我们如下所示的最终响应：

响应=组合数据完成阶段。get（）；

我曾尝试使用Jmeter进行性能测试，但未能得出结论，我想知道这种方法是否能够实现所需的吞吐量，或者需要对上述代码进行任何html" target="_blank">修改，或者考虑到这么多IO调用，java是否存在限制？如果是，那么在NodeJs中是否可行？

任何建议都将不胜感激！

Answer 1

因此，您希望通过低水平的并行性来最大化吞吐量。这样做的最好方法是使用线程，而不是CompletableFuture。当然，Node.js不是一个更好的变体。

让主线程（处理请求）启动并行线程，进行下游的其余调用。让线程将结果保存在特殊对象中，当所有其余调用完成时，该对象通知主线程。然后主线程进行处理，并将响应发送回消费者。

异步I/O的性能较低，只有当线程数量太多，无法装入可用的核心内存时，才必须使用异步I/O。