Question

我需要处理400多个员工对象，其中包括为每个对象调用一个可观察的服务方法。

我需要知道所有员工何时被处理，并且我需要找到一种方法来做到这一点，这不会导致我的客户端或服务器因同时请求而过载 - 这就是目前正在发生的事情。

我想将每个员工处理的结果收集到一个数组中，我可以从中进一步处理数据（我正在创建一个导出文件）。

我一直在尝试RxJS concat 和 forkjoin 但我似乎还有400多个任务全部解雇同时关闭。

I read this page关于 concat ，这表明处理是一次一个地处理的（就像ATM上的队列一样）但是我我不相信 - 我的浏览器再次挂起，并且网络请求的数量同时显示在我身上。

如果我能够让代码一次处理一个员工并在处理列表中的下一个员工之前完成，那就没问题了。

processEmployees(): AsyncSubject<boolean> {
    let employeesProcessed: AsyncSubject<boolean> = new AsyncSubject<boolean>();
    let listOfProcessesToRun = [];

    this.employeeProfilesList.forEach(
        (employeeProfile: EmployeeProfile) => {
            listOfProcessesToRun.push(
                this.annualLeaveCalculationService.startProcess(employeeProfile, this.yearToProcess).delay(2000)
            );
        }
    )

    Observable.concat(listOfProcessesToRun)
        .finally(() => {
        })
        .subscribe(
        (calculationResults: AnnualLeaveCalculationResults) => {
            this.calculationResults.push(calculationResults);
            employeesProcessed.complete();
        },
        error => {
        });

    return employeesProcessed;
}

我已经尝试使用 Observable.forkjoin 来处理一系列可观察对象，但我相信请求是并行处理的，这导致我的机器因为存在而挂起大约400名员工要处理。

我考虑过嵌套解决方案，例如

processemployee(X) {
    doServiceCall(this.employees[x])
    .subscribe( response => {
            processemployee(++x); // with a check to detect number of loops
        }
    );
}

但我不确定这是一个很棒的模式。

Answer 1

您可以使用带有concurreny的{{3}}重载，并将其设置为服务的理智（如20req并发）。这样，您可以优化最大吞吐量，而不会淹没您的服务器。

Answer 2

如果我理解了这个问题，我最近会遇到类似的问题。

我有成千上万的并行处理请求。这个数字太高了，整个事情都崩溃了。

然后我指出要使用bufferCount()和concatMap()运算符的组合来实现我想要的目标。

bufferCount()将原始流划分为块，全部包含相同数量的元素
concatMap()通过函数详细说明第一个块（并行）作为参数传递 - 函数返回一个Observable - 当 Observable完成，然后第二个块被采取，依此类推

也许这种方法可以提供帮助。

如何使用RxJS处理数百个请求而不会崩溃？

2 个答案: