Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Collection.parallelStream(): pipeline di stream parallele

Crea da una collezione una pipeline di stream che può essere eseguita in parallelo. Distingui la modalità di esecuzione dall’ordine del risultato e misura i benefici.

Versione: Java SE 21

Sintassi

default Stream<E> parallelStream()

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

Collection.parallelStream() è un metodo predefinito senza argomenti di java.util.Collection<E>, disponibile da Java 8. Restituisce uno Stream<E> che ha come sorgente la collezione. L’implementazione predefinita crea uno stream parallelo a partire dal suo Spliterator<E>, ma il contratto consente di restituire uno stream sequenziale. stream(), invece, restituisce uno stream sequenziale.

Le operazioni intermedie come map() sono valutate in modo differito: un’operazione terminale come collect() avvia l’elaborazione. Usa isParallel() prima dell’operazione terminale per verificare la modalità della pipeline, non il numero di thread che eseguiranno il lavoro. Non riutilizzare lo stesso stream dopo un’operazione terminale.

L’ordine del risultato non è l’ordine in cui lavorano i thread. Se la pipeline ha un ordine di incontro definito, come nel caso di una List seguita da map(), collect(Collectors.toList()) conserva quell’ordine. Collectors.toSet() non lo garantisce, né lo fa forEach() in una pipeline parallela. Se le azioni devono rispettare l’ordine di incontro, usa forEachOrdered() su uno stream ordinato.

Non modificare una collezione sorgente non progettata per l’accesso concorrente mentre la pipeline è in esecuzione. Usa lambda senza stato e raccogli i risultati con collect(), invece di aggiungerli da forEach() a un’ArrayList condivisa. Suddividere il lavoro e unire i risultati ha un costo: in parallelo, una pipeline piccola o poco onerosa può essere più lenta. Confrontala con stream() su dati rappresentativi.

Esempi

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);
    }
}

Risultato

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

La pipeline raddoppia 13 numeri e li raccoglie nell’ordine di ingresso. L’inizio `[6, 2, 4, …]` mostra che l’ordine è stato conservato, non che i valori siano stati ordinati. L’output non dimostra né l’uso di più thread né un guadagno di velocità.

Lezioni correlate

  • Java · Lezione 24 · Avanzato · Versione: 2
  • Java · Lezione 57 · Intermedio · Versione: 2

Fonti