Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Collection.parallelStream() : pipelines de flux parallèles

Construisez à partir d’une collection un pipeline de flux qui peut s’exécuter en parallèle. Distinguez le mode d’exécution de l’ordre du résultat et mesurez le gain éventuel.

Version : Java SE 21

Syntaxe

default Stream<E> parallelStream()

Stream<E> pipeline = collection.parallelStream();

Collection.parallelStream() est une méthode par défaut sans argument de java.util.Collection<E>, disponible depuis Java 8. Elle renvoie un Stream<E> dont la collection est la source. L’implémentation par défaut crée un flux parallèle à partir de son Spliterator<E>, mais le contrat autorise un flux séquentiel. En revanche, stream() renvoie un flux séquentiel.

Les opérations intermédiaires comme map() sont évaluées à la demande : une opération terminale comme collect() déclenche le traitement. Appelez isParallel() avant cette opération pour connaître le mode du pipeline, pas le nombre de threads qui effectueront le travail. Ne réutilisez pas le même flux après une opération terminale.

L’ordre du résultat ne correspond pas à l’ordre de travail des threads. Si le pipeline possède un ordre de rencontre défini, comme avec une source List suivie de map(), collect(Collectors.toList()) conserve cet ordre. Collectors.toSet() ne le garantit pas, pas plus que forEach() dans un pipeline parallèle. Si les actions doivent suivre l’ordre de rencontre, utilisez forEachOrdered() sur un flux ordonné.

Ne modifiez pas une collection source non conçue pour un accès concurrent pendant le traitement. Utilisez des lambdas sans état et rassemblez les résultats avec collect() plutôt que de les ajouter à une ArrayList partagée depuis forEach(). Répartir le travail et fusionner les résultats a un coût : le parallélisme peut ralentir un pipeline petit ou peu coûteux. Comparez-le à stream() sur des données représentatives.

Exemples

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(3, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);

        List<Integer> doubled = numbers.parallelStream()
                .map(n -> n * 2)
                .collect(Collectors.toList());

        System.out.println(doubled);
    }
}

Résultat

[6, 2, 4, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26]

Le pipeline double 13 nombres et les rassemble dans l’ordre d’entrée. Le début `[6, 2, 4, …]` montre que cet ordre a été conservé, pas qu’un tri a eu lieu. La sortie ne prouve ni l’utilisation de plusieurs threads ni un gain de vitesse.

Leçons associées

  • Java · Leçon 24 · Avancé · Version : 2
  • Java · Leçon 57 · Intermédiaire · Version : 2

Sources