Kuinka monisäikeisyys toimii Javassa?

Question

Accepted Answer

**Monisäikeisyys** sallii Java-ohjelman ajaa useita säikeitä samanaikaisesti, mikä mahdollistaa rinnakkaisuuden (useiden CPU-ytimien käyttö) ja vastekykyisyyden (työn tekeminen ilman lukitsemista). Javassa on ensimmäisen luokan säikeiden tuki — mutta jaettu muuttuva tila tuo monimutkaisuutta (race conditions), jota on hallittava varovasti. ## Säikeiden luominen ```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); ``` **Tärkeä huomio:** kutsu `start()` (luo uusi säie), ei `run()` (joka vain suorittaa koodin nykyisessä säieessä synkronisesti). ## Ydinongelmaz: 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++` on itse asiassa kolme operaatiota (luku, lisäys, kirjoitus). Kun säikeet kietoutuvat, päivitykset häviävät — **race condition**. Tämä on rinnakkaisen ohjelmoinnin keskeinen haaste: jaettu muuttuva tila, johon useat säikeet käyttävät ilman koordinointia. ## Ratkaisut turvalliseen jaettuun tilaan ```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) ``` ## Säikeiden koordinointi ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## Nykyaikainen lähestymistapa: älä hallitse raakaa säikeitä ```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 ``` ## Miksi tämä on tärkeää Monisäikeisyys sallii Java-ohjelmien käyttää useita ytimiä ja pysyä vastekykyisinä, mutta se on myös yksi vaikeimmista alueista saada oikein — **race conditions** synkronoimattomasta jaetusta muuttuvasta tilasta aiheuttavat satunnaisia, vaikeasti uusittavia virheitä. Ymmärrys siitä, miten säikeet toimivat (`start()` vs `run()`), race-condition-ongelman ydin (miksi `count++` ei ole turvallinen) ja työkalut turvallisuuden varmistamiseen (`synchronized`, atomiset luokat, rinnakkaiskokoelmat, muuttumattomuus) on välttämätöntä oikean rinnakkaisen koodin kirjoittamiseen. Moderni paras käytäntö suosii korkeamman tason abstraktioita (ExecutorService, CompletableFuture, virtuaaliset säikeet) raakojen säikeiden hallinnon sijaan. Tämä on kriittinen tieto palvelinpuolen ja suorituskykyisen Javan osalta, ja syvä, usein testattu aihe, joka erottaa pätevät kehittäjät asiantuntijadevelopereihin.