1. Stream API auffrischen
Sie kennen die Stream API bereits – sie ist eine bequeme Art der Arbeit mit Kollektionen, die es erlaubt, kompakten und verständlichen Code zur Datenverarbeitung zu schreiben: Filtern, Sortieren, Zählen usw.
Ein klassisches Beispiel:
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
.filter(n -> n % 2 == 0)
.mapToInt(n -> n)
.sum();
System.out.println(sum); // 6 (2 + 4)
In diesem Beispiel wird die Kollektion in einen Stream umgewandelt (stream()), daraus werden nur die geraden Zahlen ausgewählt, anschließend zu int konvertiert, und das Ergebnis wird mit sum() aufsummiert.
Die Stream API macht Code kürzer und ausdrucksstärker: Statt Schritt für Schritt zu beschreiben, wie genau alles passiert, sagen Sie nur, was Sie erhalten möchten. Außerdem kann man bei Bedarf mit nur einer Zeile einfach auf parallele Verarbeitung umschalten.
2. Parallele Streams: Syntax und Funktionsweise
Wie macht man einen Stream parallel?
Ganz einfach: Statt stream() verwenden Sie parallelStream(). Oder rufen Sie die Methode .parallel() auf einem vorhandenen Stream auf.
List<Integer> numbers = ...;
int sum = numbers.parallelStream()
.filter(n -> n % 2 == 0)
.mapToInt(n -> n)
.sum();
Oder so:
numbers.stream()
.parallel() // in einen parallelen Stream umwandeln
.filter(...)
.map(...)
.sum();
Was passiert unter der Haube?
- Die Kollektion wird automatisch in Teile aufgeteilt.
- Jeder Teil wird in einem separaten Thread verarbeitet (es wird ein ForkJoinPool – ein spezieller Thread-Pool – verwendet).
- Die Ergebnisse werden zu einem Endwert zusammengeführt.
Das heißt: Wenn Sie einen Mehrkernprozessor haben, läuft die Verarbeitung tatsächlich parallel – zum Beispiel können Filterung und Summenbildung gleichzeitig auf mehreren Kernen erfolgen.
Wo ist das besonders nützlich?
- Verarbeitung großer Kollektionen (Zehntausende Elemente und mehr).
- Aufwändige Berechnungen pro Element.
- Keine Notwendigkeit, eine strikte Reihenfolge einzuhalten.
Beispiel: sequentieller vs. paralleler Stream
Schauen wir uns ein einfaches Beispiel mit der Verarbeitung eines großen Arrays an.
import java.util.*;
import java.util.stream.*;
public class ParallelStreamDemo {
public static void main(String[] args) {
List<Integer> numbers = IntStream.rangeClosed(1, 10_000_000)
.boxed()
.collect(Collectors.toList());
// Sequentieller Stream
long time1 = System.currentTimeMillis();
long count1 = numbers.stream()
.filter(n -> n % 2 == 0)
.count();
long time2 = System.currentTimeMillis();
System.out.println("Sequenziell: " + (time2 - time1) + " ms, gerade Zahlen: " + count1);
// Paralleler Stream
long time3 = System.currentTimeMillis();
long count2 = numbers.parallelStream()
.filter(n -> n % 2 == 0)
.count();
long time4 = System.currentTimeMillis();
System.out.println("Parallel: " + (time4 - time3) + " ms, gerade Zahlen: " + count2);
}
}
Probieren Sie diesen Code auf Ihrem Computer aus – höchstwahrscheinlich verarbeitet der parallele Stream die Kollektion schneller (insbesondere auf einem Mehrkernprozessor). Aber nicht immer! Details dazu weiter unten.
3. Wie es funktioniert: ForkJoinPool und automatische Aufteilung
Parallele Streams verwenden unter der Haube ForkJoinPool.commonPool(), der die Anzahl der Threads automatisch steuert (typischerweise entsprechend der Anzahl verfügbarer Prozessorkerne).
Schematisch:
+-----------------------------+
| Ihre Sammlung |
+-----------------------------+
| 1 | 2 | 3 | ... | 10 Mio |
+----+----+----+-----+--------+
| | | |
v v v v
[Thread1][Thread2]...[ThreadN]
| | | |
+----+----+-----------+
|
[Ergebniszusammenführung]
Jeder Thread verarbeitet seinen Teil, danach werden die Ergebnisse zusammengeführt.
4. Einschränkungen und Fallstricke
Parallele Streams sind kein magischer „Alles schneller machen“-Knopf. Manchmal verlangsamen sie die Ausführung sogar!
Wann Parallelisierung unvorteilhaft ist:
- Die Kollektion ist klein (bis ca. 1000 Elemente).
- Die Operation pro Element ist sehr schnell (z. B. einfach n * 2).
- Es ist eine strikte Reihenfolge der Verarbeitung erforderlich (z. B. für sequentielles Schreiben in eine Datei).
Warum? Erstellung und Synchronisation von Threads kostet ebenfalls Zeit. Ist die Aufgabe „klein“, können die Overheads den Vorteil der Parallelisierung übersteigen.
Nebenwirkungen – der Feind der Parallelität
Wenn Ihre Operationen innerhalb des Streams externe Variablen ändern, seien Sie vorsichtig!
Schlechtes Beispiel:
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int[] sum = {0};
numbers.parallelStream().forEach(n -> sum[0] += n);
System.out.println(sum[0]); // ??? (Sie erwarten 15, bekommen aber irgendetwas)
Warum? Weil mehrere Threads gleichzeitig dieselbe Variable ändern – es entsteht eine Race Condition. Der Endwert kann falsch sein.
Der richtige Weg: Verwenden Sie Stream-Methoden, die ein Ergebnis zurückgeben:
int sum = numbers.parallelStream().mapToInt(n -> n).sum();
Nicht alle Kollektionen lassen sich gleich gut parallelisieren
Einige Kollektionen (z. B. ein gewöhnliches ArrayList) lassen sich gut in Teile aufspalten. LinkedList oder ein Stream mit unendlicher Anzahl von Elementen (z. B. Stream.generate(...)) hingegen weniger.
5. Praxis: Performancevergleich
Beispiel: Suche nach der maximalen Zahl
import java.util.*;
import java.util.stream.*;
public class ParallelMaxDemo {
public static void main(String[] args) {
List<Integer> numbers = IntStream.rangeClosed(1, 30_000_000)
.boxed()
.collect(Collectors.toList());
// Sequenziell
long t1 = System.currentTimeMillis();
int max1 = numbers.stream().max(Integer::compareTo).get();
long t2 = System.currentTimeMillis();
System.out.println("Sequenziell: " + (t2 - t1) + " ms, max = " + max1);
// Parallel
long t3 = System.currentTimeMillis();
int max2 = numbers.parallelStream().max(Integer::compareTo).get();
long t4 = System.currentTimeMillis();
System.out.println("Parallel: " + (t4 - t3) + " ms, max = " + max2);
}
}
Was werden wir sehen? Auf modernen Mehrkernprozessoren ist der parallele Stream in der Regel schneller. Ersetzen Sie jedoch 30_000_000 durch 1000, wird es keinen Unterschied geben – und manchmal ist parallel sogar langsamer!
6. Anwendungsbeispiele: Filtern, Aggregation, Sortierung
Filtern und Zählen
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve", "Frank", "Grace");
long count = names.parallelStream()
.filter(name -> name.length() == 4)
.count();
System.out.println("Namen der Länge 4: " + count);
Gruppierung
List<String> words = Arrays.asList("cat", "whale", "cat", "dog", "whale", "cat");
Map<String, Long> freq = words.parallelStream()
.collect(Collectors.groupingBy(
w -> w,
Collectors.counting()
));
System.out.println(freq); // {dog=1, whale=2, cat=3}
Sortierung (hier bringt Parallelität nicht immer einen Vorteil!)
List<Integer> bigList = IntStream.rangeClosed(1, 5_000_000)
.boxed()
.collect(Collectors.toList());
long t1 = System.currentTimeMillis();
List<Integer> sorted = bigList.parallelStream()
.sorted()
.collect(Collectors.toList());
long t2 = System.currentTimeMillis();
System.out.println("Paralleles Sortieren: " + (t2 - t1) + " ms");
7. Wichtige Nuancen und Empfehlungen
Wann parallelStream() sinnvoll ist
- Die Kollektion ist groß (Zehntausende Elemente und mehr).
- Die Operation pro Element ist „schwer“ (aufwändige Berechnungen, Datei-/Netzwerkzugriffe).
- Keine Abhängigkeit von der Reihenfolge der Elemente.
- Keine Seiteneffekte (keine Änderungen externer Variablen).
Wann man parallelStream() NICHT verwenden sollte
- Die Kollektion ist klein.
- Die Operation ist schnell.
- Die Reihenfolge muss strikt erhalten bleiben.
- Es gibt Zugriff auf gemeinsame Variablen (erwägen Sie threadsichere Kollektionen oder andere Ansätze).
Wie findet man heraus, wie viele Threads verwendet werden?
Standardmäßig entspricht das der Anzahl der Prozessorkerne: Runtime.getRuntime().availableProcessors(). Man kann dieses Verhalten über eine Systemeigenschaft ändern:
System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "8");
Tun Sie das nur, wenn Sie die Konsequenzen verstehen – sonst können Sie die CPU „zuschaufeln“ und Bremseffekte erzeugen.
8. Typische Fehler beim Arbeiten mit parallelen Streams
Fehler Nr. 1: Seiteneffekte innerhalb von forEach
Viele denken: „Jetzt fülle ich eine Liste parallel!“
List<Integer> result = new ArrayList<>();
IntStream.range(0, 1_000)
.parallel()
.forEach(result::add); // GEFÄHRLICH!
System.out.println(result.size()); // Ergebnis – zufällig!
Warum ist das schlecht? ArrayList ist nicht threadsicher, und beim gleichzeitigen Hinzufügen aus mehreren Threads ist das Ergebnis unvorhersehbar: Es kann zu Auslassungen, Duplikaten, Ausnahmen kommen.
Lösung: Verwenden Sie Sammelmethoden des Streams (collect), die selbst für Sicherheit sorgen, oder spezielle Kollektionen.
List<Integer> result = IntStream.range(0, 1_000)
.parallel()
.boxed()
.collect(Collectors.toList());
Fehler Nr. 2: Beschleunigung bei kleinen Aufgaben erwarten
Parallelität ist nicht kostenlos! Ist die Kollektion klein, kann ein paralleler Stream aufgrund der Overheads für Planung und Synchronisation langsamer sein.
Fehler Nr. 3: Reihenfolgeverletzung
Wenn Ihnen die Reihenfolge der Elemente wichtig ist (z. B. beim Schreiben in eine Datei), verwenden Sie keine parallelen Streams – die Reihenfolge ist nicht garantiert (oder es wird langsamer).
Fehler Nr. 4: Ungeeignete Collections verwenden
Einige Kollektionen (z. B. LinkedList, exotische Strukturen) lassen sich schlecht aufteilen – die Effizienz der Parallelisierung sinkt.
Fehler Nr. 5: Thread-Sicherheit beim Sammeln der Ergebnisse ignorieren
Wenn Sie Ergebnisse manuell sammeln (z. B. in eine Liste hinzufügen), verwenden Sie threadsichere Kollektionen (CopyOnWriteArrayList, ConcurrentLinkedQueue) oder Sammelmethoden des Streams.
GO TO FULL VERSION