Hvordan fungerer multithreading i Java?

Question

Accepted Answer

**Multithreading** lar et Java-program kjøre flere tråder samtidig, noe som muliggjør parallellisme (bruk av flere CPU-kjerner) og responsivitet (utføre arbeid uten blokkering). Java har førsteklasses trådstøtte — men delt mutable state introduserer kompleksitet (race conditions) som må håndteres nøye. ## Opprette tråder ```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); ``` **Hovedfelle:** kall `start()` (oppretter en ny tråd), ikke `run()` (som bare kjører koden på gjeldende tråd synkront). ## Kjerneproblemen: 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++` er faktisk tre operasjoner (les, inkrementér, skriv). Når tråder er interleaved, mistes oppdateringer — en **race condition**. Dette er den sentrale utfordringen med samtidighet: delt mutable state som flere tråder får tilgang til uten koordinering. ## Løsninger for trygg delt 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) ``` ## Trådkoordinering ```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 moderne tilnærmingen: ikke administrer råe tråder ```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 ``` ## Hvorfor det er viktig Multithreading gjør det mulig for Java-programmer å bruke flere kjerner og forbli responsive, men det er også et av de vanskeligste områdene å få riktig — **race conditions** fra usynkronisert delt mutable state forårsaker intermittente, vanskelig-gjengrodde feil. Å forstå hvordan tråder fungerer (`start()` vs `run()`), kjerneproblemen med race conditions (hvorfor `count++` ikke er trygt), og verktøyene for å sikre sikkerhet (`synchronized`, atomic klasser, concurrent samlinger, immutability) er essensielt for å skrive korrekt samtidig kode. Modern beste praksis favoriserer abstraksioner på høyere nivå (ExecutorService, CompletableFuture, virtuelle tråder) fremfor administrasjon av råe tråder. Dette er kritisk kunnskap for server-side og high-performance Java, og et dypt, hyppig testet emne som skiller kompetente fra ekspert-utviklere.