threads-java

Threads

Kurz: Nebenläufige Ausführungsstränge innerhalb eines Java-Programms — erlauben, dass mehrere Aufgaben scheinbar gleichzeitig laufen, statt streng nacheinander.

Genauer: Ein neuer Thread startet entweder über eine eigene Thread-Unterklasse oder, gebräuchlicher, über das Runnable-Interface mit new Thread(runnable).start(). Greifen mehrere Threads gleichzeitig auf denselben veränderlichen Zustand zu, drohen Race Conditions — das synchronized-Schlüsselwort schützt kritische Codeabschnitte davor.

Im Detail

// Über Runnable + Lambda (heute üblicher als eigene Thread-Unterklasse):
Runnable aufgabe = () -> {
    for (int i = 0; i < 5; i++) {
        System.out.println("Thread läuft: " + i);
    }
};
Thread t = new Thread(aufgabe);
t.start(); // startet einen ECHTEN neuen Ausführungsstrang, NICHT t.run() aufrufen!
 
// Gemeinsamer Zustand braucht Schutz vor Race Conditions:
class Zaehler {
    private int wert = 0;
    synchronized void erhoehen() { wert++; } // nur ein Thread gleichzeitig hier drin
}

Ein häufiger Anfängerfehler: t.run() statt t.start() aufzurufen — run() führt den Code einfach im AKTUELLEN Thread aus wie eine normale Methode, ganz ohne neuen Thread zu starten; nur start() erzeugt tatsächlich einen neuen, parallel laufenden Ausführungsstrang und ruft darin run() auf. Da mehrere Threads auf denselben Speicher zugreifen können, drohen Race Conditions: greifen zwei Threads gleichzeitig lesend UND schreibend auf dasselbe Feld zu, kann das Endergebnis von der zufälligen zeitlichen Reihenfolge abhängen. Das synchronized-Schlüsselwort sorgt dafür, dass immer nur EIN Thread gleichzeitig eine kritische Methode/einen kritischen Block betreten darf, alle anderen warten.

Für komplexere Nebenläufigkeit bietet Java seit Version 5 das java.util.concurrent-Paket mit höherwertigen Werkzeugen wie ExecutorService (verwaltet einen Pool wiederverwendbarer Threads statt für jede Aufgabe einen neuen zu erzeugen) und seit Java 21 zusätzlich sehr leichtgewichtige “Virtual Threads”, die tausende gleichzeitige Aufgaben ermöglichen, ohne dass jede einen teuren echten Betriebssystem-Thread braucht.

Siehe auch: Lambda, Anonymous Classes