Kaip veikia daugiagraijumi Java?

Question

Accepted Answer

**Daugiagraijumi** leidžia Java programai paleisti kelis sriegius vienu metu, suteikdama paralelizmą (naudojant kelis CPU branduolius) ir atsakomumą (atliekant darbą be blokavimo). Java turi pirmos klasės sriegio palaikymą — tačiau bendrintas kintamas būvis įveda sudėtingumą (lenktynės), kurias reikia atidžiai valdyti. ## Sriegrų kūrimas ```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); ``` **Svarbus klipas:** paskambinkite `start()` (suavaria naują sriegi), ne `run()` (kuris tiesiog vykdomas dabartiniame srietyje sinchroniškai). ## Pagrindinė problema: lenktynės ```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++` iš tikrųjų yra trys operacijos (skaitymas, padidėjimas, rašymas). Kai sriegriai susikeičia, atnaujinimai prarašomi — **lenktynes**. Tai yra pagrindinė konkurencijos iššūkio: bendrintas kintamas būvis, kuriuo keliems sriegriais prieinama be koordinacijos. ## Saugios bendrintos būsenos sprendimai ```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) ``` ## Sriegrių koordinacija ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## Šiuolaikinis požiūris: nesaugokite neapdorotų sriegrių ```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 ``` ## Kodėl tai svarbu Daugiagraijumi suteikia Java programoms galimybę naudoti kelis branduolius ir likti atsakioms, tačiau tai taip pat yra viena iš sunkiausių sričių — **lenktynės** iš nesinkronizuoto bendrinto kintamo būvio sukelia sporadinius, sunkiai reproduciriciamus klaidų. Supratimas, kaip veikia sriegriai (`start()` vs `run()`), pagrindinė lenktynės problema (kodėl `count++` nėra saugu) ir priemonės saugumui užtikrinti (`synchronized`, atominės klasės, vienuolės kolekcijos, nekintamumas) yra nezbendintina teisingam konkurencialiam kodui rašyti. Šiuolaikine geriausia praktika pirmenybę teikia aukštesnio lygio abstrakcijoms (ExecutorService, CompletableFuture, virtualūs sriegriai) vietoj neapdoroto sriegrių valdymo. Tai yra kritinė žinias serveriui ir aukštos veikimo Java, ir žili, dažnai testuojama tema, kuri atskiria kompetentingus nuo ekspertinių kūrėjus.