0Pricing
Java Academy · Lezione

Creazione di stream paralleli

parallel() e parallelStream()

Creazione di stream paralleli è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Che cosa fanno gli stream paralleli

Uno stream parallelo suddivide i dati ed elabora i blocchi su più thread, quindi combina i risultati. L'obiettivo è ottenere una maggiore velocità di elaborazione con carichi di lavoro grandi.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int sum = IntStream.rangeClosed(1, 1000)
            .parallel()
            .sum();
        System.out.println(sum);
    }
}

parallel() su uno stream esistente

La chiamata a parallel() trasforma uno stream sequenziale in uno parallelo. Può comparire in qualsiasi punto della pipeline.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4, 5);
        int total = nums.stream()
            .parallel()
            .mapToInt(Integer::intValue)
            .sum();
        System.out.println(total);
    }
}

parallelStream() sulle collezioni

Collection.parallelStream() crea direttamente uno stream parallelo, come abbreviazione di stream().parallel().

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("a", "bb", "ccc");
        int chars = words.parallelStream()
            .mapToInt(String::length)
            .sum();
        System.out.println(chars);
    }
}

Tornare all'esecuzione sequenziale

sequential() riporta uno stream all'esecuzione su un singolo thread. Nell'intera pipeline prevale l'ultima chiamata a parallel() o sequential().

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int sum = IntStream.rangeClosed(1, 100)
            .parallel()
            .sequential()
            .sum();
        System.out.println(sum);
    }
}

Verificare isParallel

isParallel() indica se uno stream verrà eseguito in parallelo.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        System.out.println(IntStream.range(0, 10).isParallel());
        System.out.println(IntStream.range(0, 10).parallel().isParallel());
    }
}

Stesso risultato, esecuzione diversa

Per operazioni associative come la somma, gli stream paralleli e sequenziali restituiscono lo stesso risultato. Cambia solo la strategia di esecuzione.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int seq = IntStream.rangeClosed(1, 50).sum();
        int par = IntStream.rangeClosed(1, 50).parallel().sum();
        System.out.println(seq == par);
    }
}

Il ForkJoinPool comune

Gli stream paralleli usano il ForkJoinPool.commonPool() condiviso. La sua dimensione predefinita è pari al numero di processori disponibili meno uno.

public class Main {
    public static void main(String[] args) {
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

L'ordine dei thread non è garantito

Con forEach, gli stream paralleli possono stampare i risultati in qualsiasi ordine, perché i blocchi terminano in momenti diversi. Usi forEachOrdered se l'ordine è importante.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.rangeClosed(1, 5)
            .parallel()
            .forEachOrdered(System.out::println);
    }
}

La riduzione combina risultati parziali

Internamente, una riduzione parallela calcola risultati parziali per ogni blocco e li unisce con il combiner. Per essere corretta, l'operazione deve essere associativa.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int product = IntStream.rangeClosed(1, 6)
            .parallel()
            .reduce(1, (a, b) -> a * b);
        System.out.println(product);
    }
}

Raccolta in parallelo

Il framework dei collector supporta la raccolta in parallelo unendo contenitori parziali. groupingBy funziona correttamente in parallelo.

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

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("apple", "banana", "avocado", "cherry");
        Map<Character, List<String>> byFirst = words.parallelStream()
            .collect(Collectors.groupingBy(w -> w.charAt(0)));
        System.out.println(byFirst);
    }
}

Non tutti gli stream diventano più veloci

Attivare il parallelismo è semplice, ma non è sempre vantaggioso. Con dataset piccoli o operazioni poco costose, l'esecuzione parallela può essere più lenta a causa del sovraccarico di suddivisione e unione.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long count = IntStream.rangeClosed(1, 10)
            .parallel()
            .filter(n -> n % 2 == 0)
            .count();
        System.out.println(count);
    }
}

Verifica rapida

Quale pool di thread esegue gli stream paralleli per impostazione predefinita?

Riepilogo

Ha creato stream paralleli:

  • parallel() converte qualsiasi stream; parallelStream() è un'abbreviazione per le collezioni.
  • sequential() ripristina l'esecuzione sequenziale; prevale l'ultima chiamata.
  • Vengono eseguiti sul ForkJoinPool.commonPool() condiviso.
  • Per le operazioni associative, i risultati corrispondono a quelli sequenziali, ma ordine e velocità non sono garantiti.

Domande Frequenti

La lezione «Creazione di stream paralleli» è gratuita?

Sì — il testo completo di «Creazione di stream paralleli» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Creazione di stream paralleli»?

parallel() e parallelStream() Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Creazione di stream paralleli»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Creazione di stream paralleli
  2. Quando il parallelismo è utile
  3. Sicurezza dei thread ed effetti collaterali
  4. Problemi comuni
← Torna a Java Academy