Hur fungerar multithreading i Java?

Question

Accepted Answer

**Multithreading** låter ett Java-program köra flera trådar samtidigt, vilket möjliggör parallellism (använda flera CPU-kärnor) och responsivitet (utföra arbete utan blockering). Java har förstklassigt thread-stöd — men delad föränderlig tillstånd introducerar komplexitet (racing conditions) som måste hanteras noggrant. ## Skapa trådar ```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); ``` **Viktig gotcha:** anropa `start()` (skapar en ny tråd), inte `run()` (som bara kör koden på den aktuella tråden synkront). ## Kärnproblemet: racing 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++` är faktiskt tre operationer (läs, öka, skriv). När trådar sammanväxer försvinner uppdateringar — en **racing condition**. Detta är den centrala utmaningen inom concurrency: delat föränderligt tillstånd åtkomst av flera trådar utan samordning. ## Lösningar för säkert delat tillstånd ```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-samordning ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## Den moderna metoden: hantera inte råa trådar ```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 ``` ## Varför det spelar roll Multithreading möjliggör Java-program att använda flera kärnor och förbli responsiva, men det är också ett av de svåraste områdena att få rätt — **racing conditions** från osynchroniserat delat föränderligt tillstånd orsakar intermittenta, svåra-att-reproducera buggar. Förståelse för hur trådar fungerar (`start()` vs `run()`), kärnproblemet med racing condition (varför `count++` inte är säker) och verktygen för att säkerställa säkerhet (`synchronized`, atomära klasser, concurrenta samlingar, immutabilitet) är väsentlig för att skriva korrekt concurrent kod. Modern best practice gynnar abstraktion på högre nivå (ExecutorService, CompletableFuture, virtuella trådar) framför hantering av råa trådar. Detta är kritisk kunskap för server-sida och högt-prestanda Java, och ett djupt, ofta-testerat område som skiljer kompetenta från expertutvecklare.