Parallelität
Ein Rechner hat heute mehrere Prozessorkerne, und viele Programme warten die meiste Zeit – auf die Festplatte, auf die Datenbank, auf eine Antwort aus dem Netz. In beiden Fällen hilft es, mehrere Dinge gleichzeitig zu tun. Das ist mächtig – und die Quelle der heimtückischsten Fehler überhaupt.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- Threads starten und auf sie warten
- erklären, warum gemeinsame Daten ohne Schutz kaputtgehen
- Daten mit
synchronized,AtomicIntegerundConcurrentHashMapschützen - Aufgaben mit Ergebnis an einen
ExecutorServicegeben - erklären, wofür virtuelle Threads gut sind
Demo-Code: 31-parallelitaet
⤓ demo-parallelitaet.zip herunterladenDer fertige Stand aus der Vorführung – zum Nachlesen, Ausprobieren und Weiterbauen.
Entpacke die ZIP-Datei nach C:\dev\intellij. In IntelliJ: File → Open… → den Ordner 31-parallelitaet wählen → OK → Trust Project. IntelliJ erkennt die pom.xml und lädt die Bibliotheken selbst herunter – das dauert beim ersten Mal einen Moment.
Enthält: pom.xml, ErsteThreads.java, VerloreneUpdates.java, Arbeitsteilung.java, VirtuelleThreads.java, GemeinsamesKonto.java, Kontoprobe.java
Threads
Abschnitt betitelt „Threads“Ein Thread ist ein eigener Ablauf in einem Programm. Bisher hatten unsere
Programme genau einen: main. Jeder weitere bekommt ein Runnable – im Kapitel
Lambdas haben wir das
schon gesehen.
package de.drv.parallel;
/** Zwei Threads laufen gleichzeitig – in welcher Reihenfolge, bestimmt niemand von uns. */public class ErsteThreads {
public static void main(String[] args) throws InterruptedException { Thread anna = new Thread(() -> zaehle("Anna")); Thread ben = new Thread(() -> zaehle("Ben"));
anna.start(); // start, nicht run: run liefe im selben Thread, nacheinander ben.start(); System.out.println("main wartet …");
anna.join(); // warten, bis Anna fertig ist ben.join(); System.out.println("beide fertig"); }
static void zaehle(String name) { for (int i = 1; i <= 3; i++) { System.out.println(name + " " + i); try { Thread.sleep(100); // 100 Millisekunden schlafen } catch (InterruptedException e) { return; // jemand möchte, dass wir aufhören } } }
}main wartet …Ben 1Anna 1Ben 2Anna 2Ben 3Anna 3beide fertigstart()startet den Thread – und kehrt sofort zurück.mainläuft weiter, deshalb steht „main wartet …“ ganz oben. Wer stattdessenrun()aufruft, startet keinen Thread: Dann läuft der Code ganz normal immain-Thread, eins nach dem anderen.join()wartet, bis ein Thread fertig ist.- Die Reihenfolge von Anna und Ben ist bei jedem Lauf eine andere. Wann welcher Thread drankommt, entscheidet das Betriebssystem.
Thread.sleepkann eineInterruptedExceptionwerfen: Ein anderer Thread hat gebeten, aufzuhören. Die übliche Antwort ist, genau das zu tun.
Das Problem: gemeinsame Daten
Abschnitt betitelt „Das Problem: gemeinsame Daten“package de.drv.parallel;
import java.util.concurrent.atomic.AtomicInteger;
/** Vier Threads zählen denselben Zähler hoch – und verlieren dabei Schritte. */public class VerloreneUpdates {
static int unsicher = 0;
static int sicher = 0;
static synchronized void erhoeheSicher() { sicher++; }
static final AtomicInteger atomar = new AtomicInteger();
public static void main(String[] args) throws InterruptedException { Thread[] threads = new Thread[4]; for (int t = 0; t < threads.length; t++) { threads[t] = new Thread(() -> { for (int i = 0; i < 100_000; i++) { unsicher++; // lesen, plus eins, schreiben – drei Schritte erhoeheSicher(); // immer nur ein Thread gleichzeitig atomar.incrementAndGet(); // ein unteilbarer Schritt } }); threads[t].start(); } for (Thread thread : threads) { thread.join(); } System.out.println("erwartet: 400000"); System.out.println("unsicher: " + unsicher); System.out.println("synchronized: " + sicher); System.out.println("AtomicInteger:" + " " + atomar.get()); }
}erwartet: 400000unsicher: 399142synchronized: 400000AtomicInteger: 400000Vier Threads zählen je 100 000-mal hoch – und beim ungeschützten Zähler fehlen Schritte. Bei jedem Lauf andere. Warum?
unsicher++ sieht aus wie ein Schritt, sind aber drei: Wert lesen, eins
dazuzählen, Wert zurückschreiben. Lesen zwei Threads gleichzeitig 41, schreiben
beide 42 zurück – und eine Erhöhung ist verloren. Das nennt man ein
verlorenes Update (lost update), und den Fehler dahinter eine Race
Condition: Das Ergebnis hängt davon ab, wer das Rennen gewinnt.
Das Tückische: Der Fehler tritt nicht immer auf, nicht überall gleich und schon gar nicht beim Debuggen. Ein Programm kann monatelang laufen und dann einmal falsch rechnen.
Drei Wege, Daten zu schützen
Abschnitt betitelt „Drei Wege, Daten zu schützen“| Werkzeug | wie es schützt | passt für |
|---|---|---|
synchronized an einer Methode |
Nur ein Thread zur Zeit darf sie für dieses Objekt ausführen. Die anderen warten. | mehrere Schritte, die zusammengehören |
AtomicInteger, AtomicLong |
Das Erhöhen ist ein unteilbarer Schritt – incrementAndGet(). |
einzelne Zähler |
ConcurrentHashMap |
eine Map, deren Methoden – auch merge – mehrere Threads gleichzeitig vertragen |
gemeinsame Tabellen |
Das ist die Fortsetzung der Frage aus dem
Collection-Kapitel:
ArrayList und HashMap sind nicht threadsicher. Für gemeinsame Daten
gibt es die Klassen aus java.util.concurrent.
Die beste Regel ist trotzdem eine andere: Teile so wenig wie möglich. Jeder Thread arbeitet mit seinen eigenen Daten, und erst am Ende wird zusammengeführt. Genau so arbeitet der nächste Abschnitt.
Ein Pool von Threads: ExecutorService
Abschnitt betitelt „Ein Pool von Threads: ExecutorService“Threads von Hand anzulegen ist mühsam – und wer ein Ergebnis braucht, muss es
irgendwie zurückbekommen. Ein ExecutorService übernimmt beides: Er hat einen
Pool von Threads und verteilt Aufgaben darauf.
package de.drv.parallel;
import java.util.ArrayList;import java.util.List;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;
/** Ein Pool von Threads, Aufgaben mit Ergebnis: ExecutorService, Callable, Future. */public class Arbeitsteilung {
public static void main(String[] args) throws InterruptedException, ExecutionException { int bis = 5_000_000; int teile = 4;
long start = System.nanoTime(); long allein = zaehlePrimzahlen(2, bis); System.out.println("allein: " + allein + " in " + millis(start) + " ms");
start = System.nanoTime(); try (ExecutorService pool = Executors.newFixedThreadPool(teile)) { List<Future<Long>> ergebnisse = new ArrayList<>(); int schritt = bis / teile; for (int i = 0; i < teile; i++) { int von = Math.max(2, i * schritt); int ende = (i == teile - 1) ? bis : (i + 1) * schritt; // submit nimmt ein Callable – ein Lambda mit Ergebnis – und liefert sofort ein Future ergebnisse.add(pool.submit(() -> zaehlePrimzahlen(von, ende))); } long summe = 0; for (Future<Long> ergebnis : ergebnisse) { summe += ergebnis.get(); // wartet, bis dieses Teilergebnis da ist } System.out.println("zu viert: " + summe + " in " + millis(start) + " ms"); } }
/** Primzahlen im Bereich von (einschließlich) bis ende (ausschließlich). */ static long zaehlePrimzahlen(int von, int ende) { long anzahl = 0; for (int zahl = von; zahl < ende; zahl++) { if (istPrimzahl(zahl)) { anzahl++; } } return anzahl; }
static boolean istPrimzahl(int zahl) { for (int teiler = 2; (long) teiler * teiler <= zahl; teiler++) { if (zahl % teiler == 0) { return false; } } return true; }
static long millis(long start) { return (System.nanoTime() - start) / 1_000_000; }
}allein: 348513 in 408 mszu viert: 348513 in 153 ms(Die Millisekunden hängen vom Rechner ab.)
Executors.newFixedThreadPool(4)– ein Pool mit vier Threads.submit(…)nimmt eine Aufgabe und gibt sie an einen freien Thread. Die Aufgabe ist hier einCallable: ein funktionales Interface wieRunnable, aber mit Ergebnis – deshalb liefert das Lambda einen Wert.submitkehrt sofort zurück und liefert einFuture– ein Versprechen auf das Ergebnis.get()wartet, bis es da ist.- Jede Aufgabe zählt ihren eigenen Bereich. Nichts wird geteilt, erst am Ende
werden die vier Teilergebnisse addiert. Kein
synchronizednötig. - Ein
ExecutorServiceistAutoCloseable:close()am Ende destrywartet, bis alle Aufgaben fertig sind, und beendet die Threads.
Virtuelle Threads (Java 21)
Abschnitt betitelt „Virtuelle Threads (Java 21)“Ein normaler Thread ist teuer: Jeder belegt einen Thread des Betriebssystems und reserviert Speicher. Ein paar Tausend gleichzeitig – und es wird eng. Für Programme, die die meiste Zeit warten, ist das Verschwendung.
Seit Java 21 gibt es virtuelle Threads. Die JVM verwaltet sie selbst und verteilt sie auf wenige echte Threads. Wartet ein virtueller Thread, gibt er seinen echten Thread so lange frei.
package de.drv.parallel;
import java.time.Duration;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.atomic.AtomicInteger;
/** Zehntausend Aufgaben, die jeweils eine Sekunde warten – mit virtuellen Threads (seit Java 21). */public class VirtuelleThreads {
public static void main(String[] args) { AtomicInteger fertig = new AtomicInteger(); long start = System.nanoTime();
try (ExecutorService ausfuehrer = Executors.newVirtualThreadPerTaskExecutor()) { for (int i = 0; i < 10_000; i++) { ausfuehrer.submit(() -> { Thread.sleep(Duration.ofSeconds(1)); // warten – wie auf eine Antwort aus dem Netz fertig.incrementAndGet(); return null; }); } } // close wartet, bis alle Aufgaben fertig sind
System.out.println(fertig.get() + " Aufgaben in " + (System.nanoTime() - start) / 1_000_000 + " ms"); }
}10000 Aufgaben in 1037 msZehntausend Aufgaben, jede wartet eine Sekunde – zusammen eine Sekunde. Mit einem Pool aus hundert normalen Threads wären es rechnerisch hundert Sekunden.
Executors.newVirtualThreadPerTaskExecutor()gibt jeder Aufgabe ihren eigenen virtuellen Thread. Einen Pool braucht es nicht, sie kosten fast nichts.- Das Lambda ist ein
Callablemitreturn null, weilThread.sleepeineInterruptedExceptionwerfen kann. EinCallabledarf Exceptions werfen, einRunnablenicht. - Virtuelle Threads machen Warten billig, nicht Rechnen schneller. Für die Primzahlen bringen sie nichts – dort zählen die Kerne.
| Aufgabe | richtiges Werkzeug |
|---|---|
| viel rechnen (CPU) | newFixedThreadPool mit so vielen Threads wie Kernen, oder ein paralleler Stream |
| viel warten (Netz, Datenbank, Dateien) | virtuelle Threads |
Übung: Gleichzeitig
Abschnitt betitelt „Übung: Gleichzeitig“Arbeite im Demo-Projekt 31-parallelitaet.
-
Das gemeinsame Konto: Im Demo-Projekt liegen die Klasse
GemeinsamesKontound ein ProgrammKontoprobe: Vier Threads heben zusammen 120 000-mal einen Euro ab – von einem Konto mit 100 000 Euro. Richtig wäre am Ende: Kontostand 0, genau 100 000 Abhebungen. StarteKontoprobemehrmals.Terminal-Fenster Runde 17: Kontostand 35236, Abhebungen 64760…16 von 20 Runden falsch.Mach das Konto threadsicher. Warum reicht es nicht, nur
kontostanddurch einAtomicIntegerzu ersetzen? -
Mehr Threads, mehr Tempo? Verallgemeinere
Arbeitsteilungso, dass die Zahl der Threads ein Parameter ist, und miss die Primzahlsuche mit 1, 2, 4, 8 und 16 Threads. Ab wann wird es nicht mehr schneller – und was hat das mitRuntime.getRuntime().availableProcessors()zu tun? -
Warten im Netz: Rufe acht Wikipedia-Artikel ab – wie im Kapitel Ströme und Ressourcen, aber mit
BodyHandlers.ofString(). Einmal nacheinander, einmal mit virtuellen Threads gleichzeitig. Sammle die Länge jeder Antwort in einerMap. WelcheMapbrauchst du, wenn acht Threads gleichzeitig hineinschreiben? -
Für Schnelle: Zähle die Wörter aus
Texte.JAVA.repeat(1000)mit vier Threads, die je ein Viertel der Wörter mitmergein dieselbe Map eintragen. Einmal in eineHashMap, einmal in eineConcurrentHashMap. Vergleiche die Summe aller Zählungen mit der Zahl der Wörter.
Lösung
Mit synchronized an allen drei Methoden: Alle 20 Runden richtig.
Ein AtomicInteger allein reicht nicht, weil abheben zwei Schritte hat:
prüfen, ob genug da ist, und dann abziehen. Zwischen beiden kann ein
anderer Thread abheben – beide sahen noch einen Euro, beide ziehen ihn ab. Jeder
einzelne Schritt wäre atomar, die Kombination nicht. Dieses Muster heißt
check-then-act und ist einer der häufigsten Fehler in parallelem Code.
Auch die Getter sind synchronized: Sonst ist nicht sicher, dass ein Thread den
Wert sieht, den ein anderer gerade geschrieben hat.
package de.drv.parallel;
/** Stufe 1: Ein Konto, von dem mehrere gleichzeitig abheben – jetzt threadsicher. */public class GemeinsamesKonto {
private int kontostand; private int abhebungen;
public GemeinsamesKonto(int kontostand) { this.kontostand = kontostand; }
/** Prüfen und Abheben sind ein Schritt: Solange ein Thread hier drin ist, wartet jeder andere. */ public synchronized boolean abheben(int betrag) { if (kontostand >= betrag) { kontostand -= betrag; abhebungen++; return true; } return false; }
public synchronized int getKontostand() { return kontostand; }
public synchronized int getAbhebungen() { return abhebungen; }
}Lösung
8 Prozessorkerne 1 Threads: 348513 Primzahlen in 405 ms 2 Threads: 348513 Primzahlen in 250 ms 4 Threads: 348513 Primzahlen in 143 ms 8 Threads: 348513 Primzahlen in 108 ms16 Threads: 348513 Primzahlen in 112 msBis zur Zahl der Kerne wird es schneller, danach nicht mehr: Mehr Threads als Kerne müssen sich die Kerne teilen. Dass vier Threads nicht viermal so schnell sind, liegt an der Aufteilung – die großen Zahlen im letzten Viertel brauchen länger als die kleinen im ersten.
package de.drv.parallel;
import java.util.ArrayList;import java.util.List;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;
/** Stufe 2: Wie viel bringen mehr Threads? */public class Skalierung {
public static void main(String[] args) throws InterruptedException, ExecutionException { System.out.println(Runtime.getRuntime().availableProcessors() + " Prozessorkerne"); for (int threads : new int[] {1, 2, 4, 8, 16}) { long start = System.nanoTime(); long anzahl = zaehleMit(threads, 5_000_000); System.out.printf("%2d Threads: %d Primzahlen in %4d ms%n", threads, anzahl, (System.nanoTime() - start) / 1_000_000); } }
static long zaehleMit(int threads, int bis) throws InterruptedException, ExecutionException { try (ExecutorService pool = Executors.newFixedThreadPool(threads)) { List<Future<Long>> teile = new ArrayList<>(); int schritt = bis / threads; for (int i = 0; i < threads; i++) { int von = Math.max(2, i * schritt); int ende = (i == threads - 1) ? bis : (i + 1) * schritt; teile.add(pool.submit(() -> zaehle(von, ende))); } long summe = 0; for (Future<Long> teil : teile) { summe += teil.get(); } return summe; } }
static long zaehle(int von, int ende) { long anzahl = 0; for (int zahl = von; zahl < ende; zahl++) { boolean prim = true; for (int teiler = 2; (long) teiler * teiler <= zahl; teiler++) { if (zahl % teiler == 0) { prim = false; break; } } if (prim) { anzahl++; } } return anzahl; }
}Lösung
nacheinander: 767 msgleichzeitig: 108 msFast die ganze Zeit wird auf Antworten gewartet – deshalb dauern acht
gleichzeitige Anfragen kaum länger als eine. Die Map ist eine
ConcurrentHashMap, weil acht Threads gleichzeitig hineinschreiben. Auch der
HttpClient verträgt viele gleichzeitige Anfragen – einer genügt für alle.
package de.drv.parallel;
import java.io.IOException;import java.net.URI;import java.net.URLEncoder;import java.net.http.HttpClient;import java.net.http.HttpRequest;import java.net.http.HttpResponse;import java.nio.charset.StandardCharsets;import java.util.List;import java.util.Map;import java.util.TreeMap;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;
/** Stufe 3: acht Artikel abrufen – nacheinander und mit virtuellen Threads. */public class WikipediaParallel {
private static final List<String> TITEL = List.of("Köln", "Berlin", "Hamburg", "München", "Frankfurt am Main", "Stuttgart", "Düsseldorf", "Leipzig");
public static void main(String[] args) throws IOException, InterruptedException { try (HttpClient client = HttpClient.newHttpClient()) { Map<String, Integer> laengen = new ConcurrentHashMap<>();
long start = System.nanoTime(); for (String titel : TITEL) { laengen.put(titel, abrufen(client, titel)); } System.out.println("nacheinander: " + millis(start) + " ms");
laengen.clear(); start = System.nanoTime(); try (ExecutorService ausfuehrer = Executors.newVirtualThreadPerTaskExecutor()) { for (String titel : TITEL) { ausfuehrer.submit(() -> { laengen.put(titel, abrufen(client, titel)); // ConcurrentHashMap: mehrere schreiben gleichzeitig return null; }); } } System.out.println("gleichzeitig: " + millis(start) + " ms"); System.out.println(new TreeMap<>(laengen)); } }
/** Ruft die Kurzbeschreibung ab und liefert ihre Länge in Zeichen. */ static int abrufen(HttpClient client, String titel) throws IOException, InterruptedException { String kodiert = URLEncoder.encode(titel.replace(' ', '_'), StandardCharsets.UTF_8); HttpRequest anfrage = HttpRequest.newBuilder( URI.create("https://de.wikipedia.org/api/rest_v1/page/summary/" + kodiert)) .header("User-Agent", "Java-Schulung (https://java.lean-stack.rocks)") .build(); return client.send(anfrage, HttpResponse.BodyHandlers.ofString()).body().length(); }
static long millis(long start) { return (System.nanoTime() - start) / 1_000_000; }
}Lösung
91000 WörterHashMap "die": 3843, zusammen 44823ConcurrentHashMap "die": 8000, zusammen 91000Die HashMap verliert mehr als die Hälfte – bei jedem Lauf eine andere Zahl,
manchmal wirft sie sogar eine Exception. Die ConcurrentHashMap zählt immer
richtig, weil ihr merge auch bei mehreren Threads ein unteilbarer Schritt ist.
package de.drv.parallel;
import java.util.Arrays;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;
/** Stufe 4: Wörter zählen mit vier Threads – in eine HashMap und in eine ConcurrentHashMap. */public class WoerterParallel {
public static void main(String[] args) { // Der Text tausendmal hintereinander – damit es etwas zu tun gibt List<String> woerter = Arrays.stream(Texte.JAVA.repeat(1000).toLowerCase().split("[^a-zäöüß]+")) .filter(wort -> !wort.isEmpty()) .toList(); System.out.println(woerter.size() + " Wörter");
zaehle("HashMap", new HashMap<>(), woerter); zaehle("ConcurrentHashMap", new ConcurrentHashMap<>(), woerter); }
static void zaehle(String name, Map<String, Integer> anzahl, List<String> woerter) { int viertel = woerter.size() / 4; try (ExecutorService pool = Executors.newFixedThreadPool(4)) { for (int t = 0; t < 4; t++) { List<String> teil = woerter.subList(t * viertel, t == 3 ? woerter.size() : (t + 1) * viertel); pool.submit(() -> { for (String wort : teil) { anzahl.merge(wort, 1, Integer::sum); } }); } } int summe = anzahl.values().stream().mapToInt(Integer::intValue).sum(); System.out.printf("%-18s \"die\": %5d, zusammen %6d%n", name, anzahl.getOrDefault("die", 0), summe); }
}