Comment exécuter des tâches de manière non bloquante avec les exécuteurs Java et CompletableFuture ?

Exécution de tâches non bloquantes avec des exécuteurs Java

Lorsque vous travaillez avec plusieurs files d'attente de tâches, il est crucial d'éviter de bloquer des opérations qui peuvent consommer trop espace de pile. Cet article explique comment utiliser le package java.util.concurrent de Java pour soumettre des tâches à un exécuteur sans blocage, en tirant parti des rappels pour les notifications d'achèvement des tâches.

Approche de rappel

Définir une interface de rappel qui accepte le résultat souhaité ou l'état d'achèvement de la tâche. Implémentez une classe wrapper qui accepte à la fois la tâche et le rappel. Lorsque la tâche est terminée, le wrapper appelle le rappel.

CompletableFuture et exécution asynchrone

Java 8 a introduit CompletableFuture, qui offre un mécanisme plus sophistiqué pour composer des tâches asynchrones et conditionnelles. canalisations. Créez un CompletableFuture qui exécute la tâche dans un pool de threads. Ensuite, attachez un écouteur au futur qui sera invoqué à la fin de la tâche.

Exemple

L'extrait de code suivant démontre l'utilisation de CompletableFuture pour l'exécution de tâches non bloquantes. :

import java.util.concurrent.CompletableFuture;

// Service class to perform the task
class ExampleService {
    public String work() {
        // Simulated work
        char[] str = new char[5];
        ThreadLocalRandom current = ThreadLocalRandom.current();
        for (int idx = 0; idx < str.length; ++idx)
            str[idx] = (char) ('A' + current.nextInt(26));
        String msg = new String(str);
        System.out.println("Generated message: " + msg);
        return msg;
    }
}

// Main class
public class Main {
    public static void main(String[] args) {
        ExampleService svc = new ExampleService();
        CompletableFuture<String> f = CompletableFuture.supplyAsync(svc::work);
        
        // Attach a listener to the future
        f.thenAccept(result -> System.out.println("Result: " + result));
        
        // Main method can continue execution without blocking
        System.out.println("Main method exiting");
    }
}

Ce code crée un CompletableFuture qui exécute la méthode work() de manière asynchrone. La méthode thenAccept() attache un écouteur qui sera invoqué une fois CompletableFuture terminé, permettant une exécution non bloquante de la tâche.

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!