Pouvez-vous utiliser des pools de threads personnalisés avec des flux parallèles Java 8 ?

Pools de threads personnalisés pour les flux parallèles Java 8 : un guide détaillé

Les flux parallèles dans Java 8 offrent un moyen pratique d'accélérer les calculs en parallélisant opérations sur plusieurs threads. Cependant, dans les applications multithread complexes, il est crucial d'éviter les goulots d'étranglement et d'assurer l'isolation entre les modules. Cela soulève la question : pouvez-vous utiliser des pools de threads personnalisés pour le traitement des flux parallèles ?

Est-ce possible ?

La documentation standard pour les flux parallèles Java 8 ne le fait pas mentionner explicitement la possibilité d'utiliser des pools de threads personnalisés. Cependant, une solution non conventionnelle existe :

L'astuce Fork-Join Pool :

En soumettant une opération parallèle en tant que tâche à un ForkJoinPool, elle reste dans ce pool et n'utilise pas la valeur par défaut ForkJoinPool.commonPool(). Cela vous permet de créer des pools dédiés pour des modules spécifiques, isolant leurs tâches des interférences potentielles.

Mise en œuvre :

final int parallelism = 4;
ForkJoinPool forkJoinPool = null;
try {
    forkJoinPool = new ForkJoinPool(parallelism);
    final List<Integer> primes = forkJoinPool.submit(() ->
        // Parallel task here, for example
        IntStream.range(1, 1_000_000).parallel()
                .filter(PrimesPrint::isPrime)
                .boxed().collect(Collectors.toList())
    ).get();
    System.out.println(primes);
} catch (InterruptedException | ExecutionException e) {
    throw new RuntimeException(e);
} finally {
    if (forkJoinPool != null) {
        forkJoinPool.shutdown();
    }
}

Mécanisme :

La méthode ForkJoinTask.fork, qui est utilisée pour soumettre la tâche au pool, vérifie si la tâche en cours est s'exécutant dans un ForkJoinPool. Si tel est le cas, l’opération parallèle s’exécutera dans ce pool ; sinon, il utilisera le pool commun. En soumettant la tâche via un ForkJoinPool personnalisé, vous vous assurez qu'elle fonctionne dans les limites de ce pool.

Exemple :

Considérez l'exemple artificiel de la question fournie, où lent les tâches d'un module peuvent affecter d'autres tâches dans un pool de threads partagé. En créant des pools personnalisés pour différents modules et en soumettant leurs opérations parallèles à ces pools, vous évitez le problème et exploitez en toute sécurité les flux parallèles dans des scénarios complexes.

Conclusion :

Alors Les flux parallèles Java 8 ne prennent pas en charge nativement les pools de threads personnalisés, l'astuce Fork-Join Pool offre une solution viable. En soumettant des tâches parallèles en tant que tâche dans un ForkJoinPool, vous pouvez les isoler du pool par défaut et créer des pools dédiés pour des modules spécifiques, améliorant ainsi les performances et évitant les goulots d'étranglement potentiels dans les applications multithread complexes.

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!