Comment utiliser CompecuableFuture pour garantir l'ordre des demandes d'interface par lots et traiter efficacement les résultats?

Java Programmation simultanée: Utilisez la transition complets pour gérer efficacement et ordonner les demandes d'interface par lots

Un accès élevé simultané aux interfaces tierces peut améliorer considérablement l'efficacité de traitement des données, mais si l'ordre d'exécution du thread n'est pas contrôlé, le résultat final peut ne pas correspondre à l'ordre des données d'origine, ce qui entraîne des erreurs de traitement ultérieures. Cet article présente comment utiliser la transition de Java pour garantir le traitement ordonné des demandes d'interface et les résultats dans un environnement multi-thread.

Problème: Utilisez CompletableFuture.runAsync directement pour passer des appels asynchrones. En raison de l'ordre imprévisible de l'exécution du thread, le résultat retourné est incompatible avec l'ordre de la liste de données d'origine. CompletableFuture.allOf ne peut garantir que l'achèvement de toutes les tâches, et la commande ne peut être garantie.

Solution: Utilisez CompletableFuture.supplyAsync , qui renvoie le résultat. Stockez le résultat de retour de chaque tâche asynchrone dans CompletableFuture<string></string> Dans la liste, une fois toutes les tâches terminées, les résultats sont collectés dans l'ordre d'origine via stream().map(CompletableFuture::join).collect(Collectors.toList()) .

Exemple de code amélioré:

 public static void main (String [] args) {
    Liste<string> datalist = new ArrayList  (); // Liste de données d'origine // ... Initialiser le datalist ...

    ExecutorService ExecutorService = new ThreadPoolExecutor (
            10, // CorepoolSize
            20, // maximumpoolSize
            60L, // keepalivetime
            Timeunit.seconds,
            Nouveau LinkedBlockingQueue  (1024), // workQueue
            new ThreadpoolExecutor.CallerRunspolicy () // Handler
    ));

    Liste <completablefuture> > Futures = new ArrayList  ();
    for (String data: datalist) {
        Futures.add (CompletableFuture.SupplyAsync (() -> {
            logger.info ("Traitement des données: {}", données);
            // appelle l'interface tiers pour traiter les données
            // ... Logique de traitement des appels et des résultats d'interface ...
            Retour des données "- Résultat traité"; // return Processing Result}, exécutorService));
    }

    ComplecableFuture.Allof (Futures.toArray (Nouveau EXCHETABLEFUTURE [0])). ThenRun (() -> {{
        Liste<string> résultats = futures.stream ()
                .map (CompletableFuture :: join)
                .Collect (collectionners.tolist ());
        Logger.info ("Toutes les tâches terminées. Résultats: {}", json.tojSontring (résultats));
        // Résultats de traitement ultérieurs}). Thenrun (() -> ExecutorService.shutdown ());
}</string></completablefuture></string>

Le code amélioré utilise CompletableFuture.supplyAsync pour renvoyer les résultats de chaque appel d'interface et est stocké dans la liste futures . CompletableFuture.allOf garantit que les résultats sont traités une fois toutes les tâches terminées. stream().map(CompletableFuture::join).collect(Collectors.toList()) garantit que les résultats sont collectés dans l'ordre d'origine, résolvant ainsi le problème de la concurrence dans l'ordre des résultats. Le code utilise également un pool de thread personnalisé pour mieux contrôler l'utilisation des ressources.

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!