Zum Inhalt springen

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.

  • Threads starten und auf sie warten
  • erklären, warum gemeinsame Daten ohne Schutz kaputtgehen
  • Daten mit synchronized, AtomicInteger und ConcurrentHashMap schützen
  • Aufgaben mit Ergebnis an einen ExecutorService geben
  • erklären, wofür virtuelle Threads gut sind

Demo-Code: 31-parallelitaet

⤓ demo-parallelitaet.zip herunterladen

Der 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

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.

ErsteThreads.java
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
}
}
}
}
Terminal-Fenster
main wartet …
Ben 1
Anna 1
Ben 2
Anna 2
Ben 3
Anna 3
beide fertig
  • start() startet den Thread – und kehrt sofort zurück. main läuft weiter, deshalb steht „main wartet …“ ganz oben. Wer stattdessen run() aufruft, startet keinen Thread: Dann läuft der Code ganz normal im main-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.sleep kann eine InterruptedException werfen: Ein anderer Thread hat gebeten, aufzuhören. Die übliche Antwort ist, genau das zu tun.
VerloreneUpdates.java
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());
}
}
Terminal-Fenster
erwartet: 400000
unsicher: 399142
synchronized: 400000
AtomicInteger: 400000

Vier 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.

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.

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.

Arbeitsteilung.java
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;
}
}
Terminal-Fenster
allein: 348513 in 408 ms
zu 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 ein Callable: ein funktionales Interface wie Runnable, aber mit Ergebnis – deshalb liefert das Lambda einen Wert.
  • submit kehrt sofort zurück und liefert ein Future – 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 synchronized nötig.
  • Ein ExecutorService ist AutoCloseable: close() am Ende des try wartet, bis alle Aufgaben fertig sind, und beendet die Threads.

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.

VirtuelleThreads.java
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");
}
}
Terminal-Fenster
10000 Aufgaben in 1037 ms

Zehntausend 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 Callable mit return null, weil Thread.sleep eine InterruptedException werfen kann. Ein Callable darf Exceptions werfen, ein Runnable nicht.
  • 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

Arbeite im Demo-Projekt 31-parallelitaet.

  1. Das gemeinsame Konto: Im Demo-Projekt liegen die Klasse GemeinsamesKonto und ein Programm Kontoprobe: 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. Starte Kontoprobe mehrmals.

    Terminal-Fenster
    Runde 17: Kontostand 35236, Abhebungen 64760
    …
    16 von 20 Runden falsch.

    Mach das Konto threadsicher. Warum reicht es nicht, nur kontostand durch ein AtomicInteger zu ersetzen?

  2. Mehr Threads, mehr Tempo? Verallgemeinere Arbeitsteilung so, 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 mit Runtime.getRuntime().availableProcessors() zu tun?

  3. 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 einer Map. Welche Map brauchst du, wenn acht Threads gleichzeitig hineinschreiben?

  4. Für Schnelle: Zähle die Wörter aus Texte.JAVA.repeat(1000) mit vier Threads, die je ein Viertel der Wörter mit merge in dieselbe Map eintragen. Einmal in eine HashMap, einmal in eine ConcurrentHashMap. 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.

GemeinsamesKonto.java
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
Terminal-Fenster
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 ms
16 Threads: 348513 Primzahlen in 112 ms

Bis 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.

Skalierung.java
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
Terminal-Fenster
nacheinander: 767 ms
gleichzeitig: 108 ms

Fast 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.

WikipediaParallel.java
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
Terminal-Fenster
91000 Wörter
HashMap "die": 3843, zusammen 44823
ConcurrentHashMap "die": 8000, zusammen 91000

Die 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.

WoerterParallel.java
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);
}
}