Wie funktioniert Multithreading in Java?

Question

Accepted Answer

**Multithreading** ermöglicht es einem Java-Programm, mehrere Threads gleichzeitig auszuführen, was Parallelismus (Verwendung mehrerer CPU-Kerne) und Responsivität (Ausführung von Arbeit ohne Blockierung) ermöglicht. Java hat erstklassige Thread-Unterstützung — aber gemeinsam genutzter veränderlicher Zustand führt zu Komplexität (Race Conditions) ein, die sorgfältig verwaltet werden müssen. ## Threads erstellen ```java // 1. Implement Runnable (preferred — separates task from thread) Runnable task = () -> System.out.println("running on " + Thread.currentThread().getName()); Thread t = new Thread(task); t.start(); // start() runs it on a NEW thread (run() would run on the CURRENT thread!) // 2. modern: use an ExecutorService instead of raw threads ExecutorService executor = Executors.newFixedThreadPool(4); executor.submit(task); ``` **Wichtige Falle:** Rufen Sie `start()` auf (erzeugt einen neuen Thread), nicht `run()` (die den Code nur auf dem aktuellen Thread synchron ausführt). ## Das Kernproblem: Race Conditions ```java // ❌ multiple threads modifying shared state → unpredictable results class Counter { int count = 0; void increment() { count++; } // NOT atomic: read → add → write (can interleave) } // 1000 threads each incrementing 1000 times → final count is often < 1,000,000! ``` `count++` sind eigentlich drei Operationen (Lesen, Inkrementieren, Schreiben). Wenn sich Threads verschränken, gehen Updates verloren — eine **Race Condition**. Dies ist die zentrale Herausforderung der Nebenläufigkeit: gemeinsam genutzter veränderlicher Zustand, auf den mehrere Threads ohne Koordination zugreifen. ## Lösungen für sicheren gemeinsam genutzten Zustand ```java // 1. synchronized — only one thread in the method/block at a time (a lock) synchronized void increment() { count++; } // 2. atomic classes — lock-free atomic operations AtomicInteger count = new AtomicInteger(0); count.incrementAndGet(); // atomic, thread-safe, efficient // 3. concurrent collections — built for multi-threaded access ConcurrentHashMap map = new ConcurrentHashMap<>(); // 4. immutability — immutable objects are inherently thread-safe (nothing to corrupt) ``` ## Thread-Koordination ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## Der moderne Ansatz: Verwalten Sie keine rohen Threads ```text ✓ Use ExecutorService / thread pools (not new Thread() per task — expensive) ✓ Use CompletableFuture for async composition ✓ Use concurrent collections and atomic classes over manual synchronization ✓ Java 21+ adds Virtual Threads — millions of lightweight threads for I/O concurrency ``` ## Warum es wichtig ist Multithreading ermöglicht Java-Programmen, mehrere Kerne zu nutzen und responsiv zu bleiben, ist aber auch einer der schwierigsten Bereiche, um es richtig zu machen — **Race Conditions** aus nicht synchronisiertem gemeinsam genutztem veränderlichem Zustand verursachen intermittierende, schwer zu reproduzierende Fehler. Das Verständnis, wie Threads funktionieren (`start()` vs `run()`), das Kernproblem der Race Condition (warum `count++` nicht sicher ist) und die Werkzeuge zur Gewährleistung der Sicherheit (`synchronized`, atomare Klassen, Concurrent Collections, Unveränderlichkeit) sind unerlässlich für das Schreiben von korrektem Concurrent-Code. Moderne Best Practices bevorzugen höherwertige Abstraktionen (ExecutorService, CompletableFuture, virtuelle Threads) gegenüber direkter Thread-Verwaltung. Dies ist kritisches Wissen für serverseitige und hochleistungs-Java und ein tiefes, häufig getestetes Thema, das kompetente von Experten-Entwicklern unterscheidet.