Java Academy · Lektion

Parallele Streams erstellen

parallel() und parallelStream()

Parallele Streams erstellen ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was parallele Streams tun

Ein paralleler Stream teilt seine Daten auf, verarbeitet die Teilmengen in mehreren Threads und führt die Ergebnisse anschließend zusammen. Ziel ist ein höherer Durchsatz bei großen Arbeitsmengen.

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() für einen vorhandenen Stream

Der Aufruf von parallel() wandelt einen sequenziellen Stream in einen parallelen um. Er kann an beliebiger Stelle in der Pipeline stehen.

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() für Collections

Collection.parallelStream() erstellt direkt einen parallelen Stream – als Kurzform von 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);
    }
}

Zur sequenziellen Verarbeitung zurückkehren

sequential() stellt die Ausführung in einem einzelnen Thread wieder her. Für die gesamte Pipeline gilt der letzte Aufruf von parallel() oder 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);
    }
}

isParallel überprüfen

isParallel() gibt an, ob ein Stream parallel ausgeführt wird.

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

Gleiches Ergebnis, andere Ausführung

Bei assoziativen Operationen wie einer Summe liefern parallele und sequenzielle Streams das gleiche Ergebnis. Nur die Ausführungsstrategie unterscheidet sich.

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

Der gemeinsame ForkJoinPool

Parallele Streams verwenden den gemeinsam genutzten ForkJoinPool.commonPool(). Seine Standardgröße entspricht der Anzahl verfügbarer Prozessoren minus eins.

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

Die Reihenfolge der Threads ist nicht garantiert

Bei forEach können parallele Streams die Ausgabe in beliebiger Reihenfolge erzeugen, weil Teilmengen zu unterschiedlichen Zeitpunkten fertig werden. Verwenden Sie forEachOrdered, wenn die Reihenfolge wichtig ist.

import java.util.stream.IntStream;

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

Reduktion führt Teilergebnisse zusammen

Intern berechnet eine parallele Reduktion Teilergebnisse für jede Teilmenge und führt sie mit dem Kombinierer zusammen. Für korrekte Ergebnisse muss die Operation assoziativ sein.

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

Parallel sammeln

Das Collector-Framework unterstützt das parallele Sammeln, indem es teilweise gefüllte Container zusammenführt. groupingBy funktioniert auch parallel korrekt.

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

Nicht jeder Stream wird schneller

Parallelisierung lässt sich trivial aktivieren, ist aber nicht immer vorteilhaft. Bei kleinen Datenmengen oder günstigen Operationen kann die parallele Verarbeitung durch den Aufwand für Aufteilung und Zusammenführung langsamer sein.

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

Kurze Prüfung

Welcher Thread-Pool führt parallele Streams standardmäßig aus?

Zusammenfassung

Sie haben parallele Streams erstellt:

parallel() wandelt jeden Stream um; parallelStream() ist eine Kurzform für Collections.
sequential() stellt die sequenzielle Verarbeitung wieder her; der letzte Aufruf gilt.
Sie werden im gemeinsam genutzten ForkJoinPool.commonPool() ausgeführt.
Bei assoziativen Operationen stimmen die Ergebnisse mit der sequenziellen Verarbeitung überein, aber Reihenfolge und Geschwindigkeit sind nicht garantiert.

Häufig gestellte Fragen

Ist die Lektion „Parallele Streams erstellen“ kostenlos?

Ja — der vollständige Text von „Parallele Streams erstellen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Parallele Streams erstellen“?

parallel() und parallelStream() Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Parallele Streams erstellen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Java Academy