Hoe werkt multithreading in Java?

Question

Accepted Answer

**Multithreading** stelt een Java-programma in staat om meerdere threads gelijktijdig uit te voeren, wat parallellisme (gebruik van meerdere CPU-cores) en responsiviteit (werk zonder blokkering) mogelijk maakt. Java heeft first-class thread support — maar gedeelde mutable state introduceert complexiteit (race conditions) die voorzichtig moet worden beheerd. ## Threads aanmaken ```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); ``` **Belangrijkste voetval:** roep `start()` aan (maakt een nieuwe thread), niet `run()` (voert alleen code synchrone uit op de huidige thread). ## Het kernprobleem: 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++` bestaat eigenlijk uit drie bewerkingen (lezen, verhogen, schrijven). Wanneer threads interleaven, gaan updates verloren — een **race condition**. Dit is de centrale uitdaging van gelijktijdigheid: gedeelde mutable state benaderd door meerdere threads zonder coördinatie. ## Oplossingen voor veilige gedeelde state ```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 coördinatie ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## De moderne benadering: beheer geen ruwe 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 ``` ## Waarom het belangrijk is Multithreading stelt Java-programma's in staat om meerdere cores te gebruiken en responsief te blijven, maar het is ook een van de lastigste gebieden om correct uit te voeren — **race conditions** van ongesynchroniseerde gedeelde mutable state veroorzaken ondermijning, moeilijk te reproduceren bugs. Het begrijpen hoe threads werken (`start()` vs `run()`), het kernprobleem van race conditions (waarom `count++` niet veilig is), en de tools om veiligheid te garanderen (`synchronized`, atomic classes, concurrent collections, immutability) is essentieel voor het schrijven van correcte gelijktijdige code. Moderne best practice geeft de voorkeur aan abstracties op hoger niveau (ExecutorService, CompletableFuture, virtual threads) boven beheer van ruwe threads. Dit is kritieke kennis voor server-side en high-performance Java, en een diep, veelvuldig getest onderwerp dat competente van deskundige developers onderscheidt.