CKTIS / Java
Rispettare l’ordine di incontro con Stream.forEachOrdered
Usa `forEachOrdered` se un’azione terminale deve seguire l’ordine di incontro dello stream, anche in una pipeline parallela. Il normale `forEach` non offre questa garanzia in modalità parallela.
Versione: Java SE 21
Sintassi
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);In Java SE 21, Collection.parallelStream() crea uno stream che ha come sorgente la collezione. L’implementazione predefinita lo crea in modalità parallela, ma il contratto consente di restituire uno stream sequenziale. La modalità parallela non garantisce né l’uso di più thread né una maggiore velocità.
Stream.forEachOrdered(action) è un’operazione terminale che restituisce void. Accetta un Consumer<? super T> ed esegue l’azione per ogni elemento che arriva alla fine della pipeline, seguendo l’ordine di incontro se è definito. Per una List è l’ordine degli elementi nella lista, e filter conserva l’ordine relativo degli elementi che superano il filtro. Un HashSet di per sé non definisce un ordine simile. forEachOrdered non ordina gli elementi e non impone un ordine dove non c’è.
Le azioni terminali vengono eseguite una alla volta: l’azione per un elemento precede, nel senso di happens-before, le azioni per gli elementi successivi. Le azioni possono essere eseguite su thread diversi e le fasi precedenti possono continuare a essere eseguite in parallelo. La garanzia riguarda queste chiamate, non gli accessi indipendenti di altri thread allo stato condiviso.
Il normale Stream.forEach(action) non garantisce l’ordine di incontro in una pipeline parallela, anche se una singola esecuzione può rispettarlo per caso. Usalo solo quando l’ordine delle azioni non conta e rendi sicuri gli accessi allo stato condiviso. Con entrambi i metodi, l’azione non deve interferire con la sorgente dello stream. Non riutilizzare lo stream dopo un’operazione terminale: creane uno nuovo per un altro passaggio.
Esempi
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());
}
}Risultato
5 1 3 Count: 3
La prima pipeline stampa i numeri dispari nell’ordine della lista: `5`, `1`, `3`, non in ordine crescente. La seconda usa `forEach` solo per confronto: incrementa un contatore atomico, quindi `Count: 3` non dipende dall’ordine delle azioni. Se devi solo contare, usa `count()` al posto di un contatore condiviso.
Lezioni correlate
- Java · Lezione 43 · Avanzato · Versione: 2
- Java · Lezione 57 · Intermedio · Versione: 2