Comment attendre efficacement plusieurs contrats à terme et gérer les exceptions : CompletionService ou contrôles futurs individuels ?

Mise en œuvre optimale pour attendre sur une liste de futurs

La programmation asynchrone offre des avantages tels qu'une réactivité accrue et une utilisation efficace des ressources. Cependant, la gestion simultanée de plusieurs futurs peut présenter des difficultés en matière de coordination de leur réalisation et de gestion efficace des exceptions. Cet article explore une solution au problème de l'attente jusqu'à ce que tous les futurs d'une liste soient terminés ou qu'une exception se produise dans l'un d'entre eux.

L'approche simple consiste à vérifier chaque futur individuellement à l'aide de Future.get(). Cependant, cette méthode devient inefficace pour les grandes listes, car elle nécessite d'attendre que tous les futurs soient terminés même si une erreur se produit dans une tâche antérieure.

Une solution alternative consiste à utiliser un CompletionService. Ce service fournit une méthode bloquante take() qui permet à l'appelant de recevoir les contrats à terme terminés dès qu'ils deviennent disponibles. Simultanément, il permet d'annuler les tâches en cours en cas d'erreurs.

Considérons l'implémentation suivante :

<code class="java">Executor executor = Executors.newFixedThreadPool(4);
CompletionService<SomeResult> completionService =
    new ExecutorCompletionService<SomeResult>(executor);

// Submit 4 tasks
for (int i = 0; i < 4; i++) {
    completionService.submit(new Callable<SomeResult>() {
        public SomeResult call() {
            ... // Task logic
            return result;
        }
    });
}

int received = 0;
boolean errors = false;

// Monitor future completion and errors
while (received < 4 && !errors) {
    Future<SomeResult> resultFuture = completionService.take(); // Blocks if no futures available
    try {
        SomeResult result = resultFuture.get();
        received++;
        ... // Process result
    } catch (Exception e) {
        // Log error
        errors = true;
    }
}</code>

Dans cette implémentation, le CompletionService reçoit les futurs terminés via sa méthode take() . Si une tâche génère une exception, l'indicateur d'erreurs est défini sur true et la boucle se termine. Cette approche réduit considérablement le temps d'attente pour les tâches suivantes, ce qui se traduit par une gestion des exceptions plus efficace.

Si vous le souhaitez, vous pouvez améliorer cette solution en annulant toutes les tâches en attente lorsqu'une erreur se produit, garantissant ainsi que les ressources sont libérées rapidement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!