CompleteFuture est une classe introduite dans Java 8 pour simplifier la programmation asynchrone et le traitement des taches multithread. 1. Il prend en charge l'achèvement manuel des appels à la cha?ne future, la combinaison de multiples opérations asynchrones et la manipulation des exceptions unifiées; 2. Comparé à Java 5 Future, il est plus puissant et peut définir manuellement les résultats, les opérations de cha?ne, combiner des taches et manipuler de manière flexible les exceptions; 3. Utilisez SupplyAsync ou Runasync pour créer des taches asynchrones et spécifier des pools de threads; 4. à convertir ensuite les résultats, les résultats de la consommation acceptoraient ensuite les opérations ultérieures; 5. Taches de combinaison en série de thencompose, résultats de fusion parallèle de la thencombine; 6. Méthodes exceptionnelles et manipulées gérer les exceptions et fournir des valeurs par défaut ou une logique unifiée.

CompleteFuture est une classe introduite dans Java 8 pour gérer plus facilement la programmation asynchrone et les taches multithread. En termes simples, c'est un avenir manuel qui peut être achevé, prend en charge les appels de cha?ne, combine plusieurs opérations asynchrones et peut gérer les exceptions.

Qu'est-ce que l'avenir?

Avant de parler de FeleableFuture, vous devez d'abord comprendre Future . Il s'agit d'une interface introduite dans Java 5 pour représenter le résultat d'un calcul asynchrone. Vous pouvez soumettre une tache au pool de threads, obtenir un avenir, puis utiliser la méthode get() pour obtenir le résultat.

Mais l'avenir a un problème: la fonctionnalité est trop basique. Par exemple:

• Impossible de définir les résultats manuellement
• Le fonctionnement de la cha?ne n'est pas pris en charge
• Difficile de combiner les résultats avec plusieurs futurs
• La manipulation des exceptions n'est pas suffisamment flexible

CompletsableFuture est con?u pour résoudre ces problèmes.

Utilisez la transition terminée pour effectuer des taches asynchrones

Vous pouvez créer une tache asynchrone qui s'exécute en arrière-plan et le fil principal continue d'effectuer d'autres opérations.

 EXCHETABLEFUTURE <string> futur = EXCHETABLEFUTURE.SUPPLYASYNC (() -> {
    // opération de temps de simulation essaie {
        Thread.Sleep (1000);
    } catch (InterruptedException e) {
        e.printStackTrace ();
    }
    retourner "Bonjour d&#39;Async";
});

Le code ci-dessus exécutera des taches de manière asynchrone dans le pool de threads. La valeur par défaut est ForkJoinPool.commonPool() , et vous pouvez également la transmettre dans votre propre pool de threads.

Si vous devez attendre le résultat, appelez:

 String result = future.get (); // bloquera jusqu'à ce que le résultat soit prêt

Appel de cha?ne: puisapply, alorsaccept, thenrun

Completefuture prend en charge les appels de cha?ne, ce qui rend le lien entre les opérations asynchrones plus naturel.

Alors appliquez: convertissez le résultat

 CompleteFuture <Integer> futur = completefuture.Supplyasync (() -> "Bonjour")
    .ThenApply (s -> s.Length ());

Cela signifie de retourner la cha?ne "bonjour" de manière asynchrone, puis de la transformer en longueur 5.

Ensuite, le résultat de la consommation (pas de rendement)

 EXCHETABLEFUTURE <VOID> FUTUR = EXCOMPLABLEFUTURE.SUPPLYASYNC (() -> "World")
    .TheNaCcept (System.out :: println);

Imprimez le monde, mais ne renvoie pas la valeur.

Thenrun: exécutez des actions ultérieures (sans se soucier des résultats précédents)

 ComplecableFuture <Void> futur = completsablefuture.runasync (() -> System.out.println ("Tache 1"))
    .ThenRun (() -> System.out.println ("Tache 2"));

Combinant plusieurs taches asynchrones: le thencompose et la thencombine

THENCOMOSE: Composition en série

Convient pour prendre le résultat de la tache précédente en entrée dans la tache suivante.

 EXCHETABLEFUTURE <Integer> futur = terminableFuture.SupplyAsync (() -> "123")
    .ThenCompose (S -> CompletableFuture.SupplyAsync (() -> Integer.ParseInt (S)));

Thencombine: combinez deux taches en parallèle et fusionnez les résultats

 CompleteFuture <Integer> futur1 = completfuture.SupplyAsync (() -> 10);
CompleteFuture <Integer> futur2 = completfuture.SupplyaSync (() -> 20);

futur1.thenombine (futur2, (a, b) -> ab);

De cette fa?on, les deux résultats asynchrones peuvent être additionnés.

Gestion des exceptions: exceptionnellement et manipuler

Les taches asynchrones peuvent également provoquer des erreurs, et la transition complète fournit un moyen de gérer les exceptions.

Exceptionnellement: fournir une valeur par défaut lorsqu'une exception se produit

 CompleteFuture <Integer> futur = completefuture.supplyasync (() -> {
    if (true) lancer une nouvelle RuntimeException ("oups");
    retour 100;
}). Exceptionnellement (ex -> {
    System.out.println ("L&#39;erreur s&#39;est produite:" ex.getMessage ());
    retour 0; // valeur par défaut});

Poignée: il sera exécuté, qu'il s'agisse d'une exception et peut être géré de manière unifiée

 CompleteFuture <Integer> futur = completefuture.supplyasync (() -> {
    retour 100;
}). manche ((résultat, ex) -> {
    if (ex! = null) {
        System.out.println ("Exception:" Ex.GetMessage ());
        retour 0;
    }
    Résultat de retour * 2;
});

Résumer les méthodes courantes

• Créer une tache asynchrone: supplyAsync / runAsync
• Résultat de la conversion: thenApply
• Résultats de la consommation: thenAccept
• Opération de suivi: thenRun
• Combinaison en série: thenCompose
• Combinaison parallèle: thenCombine
• Gestion des exceptions: exceptionally / handle

Fondamentalement, c'est tout. La transition complète est puissante, mais cela peut sembler un peu compliqué lorsque vous commencez. Il est recommandé de commencer par des taches simples et de ma?triser progressivement les appels de cha?ne et les méthodes de combinaison.

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!