Les requêtes parallèles avec RXJS amélioreront-elles les performances?

Problème: j'ai besoin de télécharger un fichier énorme (5-10 Go) avec de simples requêtes XHR, pour simplifier une question que je dois faire au moins: 100 requêtes (peut-être plus). Je voudrais en améliorer les performances en utilisant RXJS (requêtes http parallèles).

Les questions:

1. Est-il possible d'améliorer les performances avec Parallel?
2. La parallélisation des requêtes ne sera-t-elle pas la même chose que l'utilisation d'une requête pour chaque itération de la boucle de requête? La bande passante est la même - NON?
3. Existe-t-il d'autres moyens d'améliorer mes performances?

Stack:

• Angulaire 7.2.x
• Typescript 3.2.4
• Rxjs 6.4.0

Ce que j'ai réellement atteint: Ce dont j'ai réellement besoin, c'est d'appliquer la synchronisation sur mergeMap pour l'activer / la désactiver, par exemple j'ai 100urls mais je ne souhaite pas qu'elles s'exécutent avant la dernière.

Par exemple, je veux qu'il s'exécute jusqu'au 17, mais je suspendrai les demandes et attendrons que certaines logiques et demandes se terminent.

Exemple de code:

from(observableQueries)
           .pipe(
               mergeMap(partialQuery => this.messageService.getResults(partialQuery, true), 4),
               takeWhile(o => {
                   if (!o.isMoreResults && o.auditMessageList.length === 0) {
                       this.logger.log(`First page that returns false ${ o.number }`);
                       this.logger.log(`Count of responses that exists in array: ${ allResults.length }`);
                       if (!firstPageThatShouldBeStopped) {
                           firstPageThatShouldBeStopped = o.number;
                       }

                       if (allResults.length === firstPageThatShouldBeStopped) {
                           return false;
                       }
                   }
                   return true;
               }),
               retryWhen(genericRetryStrategy()),
               catchError((err, caught) => {
                   this._alertService.error(this._translate.instant('EXPORT_TO_CSV_DOWNLOAD_ERROR'));
                   return throwError(err);
               })
           )
           .subscribe(
               (res: MessagesResult) => {
                   if (reThrowError) {
                       this.logger.info('Error will be thrown for e2e purposes');
                       throw new Error('Error will throw for e2e purposes');
                   }
                   if (res.isMoreResults && res.auditMessageList.length > 0) {
                       allResults[res.number] = res;
                       this.subject.next(true);
                   } else if (!res.isMoreResults && res.auditMessageList.length > 0) {
                       allResults[res.number] = res;
                       this.subject.next(true);
                   } else {
                       this.subject.next(false);
                   }
               },
               err => {
                   // clear subject after emitting value...
                   this.subject.next(true);
                   return this.handleError(err);
               },
               () => {
                   this.logger.info('Download file finished...');
                   this.logger.info('Time consumed: ', performance.now() - start);
                   try {
                       this.logger.info(`Count Responses: ${ allResults.length } `);
                       const allResultSorted = this._sortResults(allResults);
                       let counter = 0;
                       for (let i = 0; i < allResultSorted.length; i++) {
                           this.logger.info('Index: ' + i, allResultSorted[i]);
                           counter += allResultSorted[i].auditMessageList.length;
                           this.logger.info('Length OF Messages: ' + i, counter);
                           this.fileSaver.save(!allResultSorted[i].isMoreResults, allResultSorted[i].auditMessageList,
                               `audit-events_${ LOCAL_QUERY_COPY.application }_${ timestamp }_${ moment()
                                   .tz(this._timezoneService.timezone).zoneName() }.csv`, null, headers);
                       }
                       this.subject.next(false);
                   } catch (e) {
                       this._alertService.error(this._translate.instant('EXPORT_TO_CSV_DOWNLOAD_ERROR'));
                       return this.handleError(e);
                   } finally {
                       // clear subject after emitting value...
                       this.subject.next(true);
                   }
               }
           );

Le code fonctionne! Mais le problème vient des appels redondants. Comment il serait possible de les arrêter jusqu'à ce que les dernières requêtes soient exécutées.