CKTIS / Java
Respecter l’ordre de rencontre avec Stream.forEachOrdered
Utilisez `forEachOrdered` si une action terminale doit suivre l’ordre de rencontre du flux, même dans un pipeline parallèle. En mode parallèle, `forEach` ne donne pas cette garantie.
Version : Java SE 21
Syntaxe
java.util.Collection<E>: default Stream<E> parallelStream()
java.util.stream.Stream<T>: void forEachOrdered(Consumer<? super T> action)
Contrast on java.util.stream.Stream<T>: void forEach(Consumer<? super T> action)
collection.parallelStream().forEachOrdered(action);Dans Java SE 21, Collection.parallelStream() crée un flux dont la collection est la source. L’implémentation par défaut le crée en mode parallèle, mais le contrat autorise une implémentation à renvoyer un flux séquentiel. Le mode parallèle ne garantit ni l’utilisation de plusieurs threads ni un gain de vitesse.
Stream.forEachOrdered(action) est une opération terminale qui renvoie void. Elle reçoit un Consumer<? super T> et exécute l’action pour chaque élément qui atteint la fin du pipeline, en suivant l’ordre de rencontre s’il est défini. Pour une List, c’est l’ordre des éléments de la liste, et filter préserve l’ordre relatif des éléments retenus. Un HashSet ne définit pas à lui seul un tel ordre. forEachOrdered ne trie pas les éléments et ne crée pas d’ordre s’il n’en existe pas.
Les actions terminales s’exécutent une à une : l’action pour un élément précède au sens de happens-before les actions pour les éléments suivants. Les actions peuvent s’exécuter sur des threads différents, et les étapes précédentes peuvent rester parallèles. La garantie s’applique à ces appels, pas aux accès indépendants d’autres threads à un état partagé.
Dans un pipeline parallèle, Stream.forEach(action) ne garantit pas l’ordre de rencontre, même si une exécution donnée le respecte par hasard. Utilisez-le seulement si l’ordre des actions est sans importance et sécurisez tout accès à un état partagé. Dans les deux méthodes, l’action ne doit pas interférer avec la source du flux. Après une opération terminale, ne réutilisez pas le même flux : créez-en un autre pour un nouveau parcours.
Exemples
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
public class Main {
public static void main(String[] args) {
List<Integer> numbers = List.of(5, 2, 1, 4, 3);
numbers.parallelStream()
.filter(n -> n % 2 != 0)
.forEachOrdered(System.out::println);
AtomicInteger matches = new AtomicInteger();
numbers.parallelStream()
.filter(n -> n % 2 != 0)
.forEach(n -> matches.incrementAndGet());
System.out.println("Count: " + matches.get());
}
}Résultat
5 1 3 Count: 3
Le premier pipeline affiche les nombres impairs dans l’ordre de la liste : `5`, `1`, `3`, et non dans l’ordre croissant. Le second utilise `forEach` uniquement pour la comparaison : il incrémente un compteur atomique, donc `Count: 3` ne dépend pas de l’ordre des actions. Pour un simple comptage, utilisez `count()` plutôt qu’un compteur partagé.
Leçons associées
- Java · Leçon 43 · Avancé · Version : 2
- Java · Leçon 57 · Intermédiaire · Version : 2