Jak funguje multithreading v Javě?

Question

Accepted Answer

**Multithreading** umožňuje Java programu spouštět více vláken souběžně, což umožňuje paralelismus (použití více CPU jader) a responsivnost (provádění práce bez blokování). Java má podporu vláken první třídy — ale sdílený měnitelný stav zavádí složitost (race conditions), kterou je třeba pečlivě spravovat. ## Vytváření vláken ```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); ``` **Klíčová pozornost:** volejte `start()` (vytvoří nové vlákno), ne `run()` (která pouze spustí kód na aktuálním vlákně synchronně). ## Základní problém: 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++` je vlastně tři operace (čtení, inkrementace, zápis). Když se vlákna proloží, aktualizace se ztratí — **race condition**. Toto je ústředním problémem konkurence: sdílený měnitelný stav přístupný více vlákny bez koordinace. ## Řešení pro bezpečný sdílený stav ```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) ``` ## Koordinace vláken ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## Moderní přístup: nespravujte surová vlákna ```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 ``` ## Proč je to důležité Multithreading umožňuje Java programům využívat více jader a zůstat responsivní, ale je to také jedna z nejtěžších oblastí, ve které dosáhnout správného výsledku — **race conditions** z nesynchronizovaného sdíleného měnitelného stavu způsobují intermitentní, těžko reprodukovatelné chyby. Porozumění tomu, jak vlákna fungují (`start()` vs `run()`), základní problém race-condition (proč `count++` není bezpečné), a nástroje pro zajištění bezpečnosti (`synchronized`, atomické třídy, souběžné kolekce, imutabilita) jsou nezbytné pro psaní správného souběžného kódu. Moderní osvědčená praxe dává přednost abstrakci vyšší úrovně (ExecutorService, CompletableFuture, virtuální vlákna) před správou surových vláken. Toto je kritické znalosti pro serverový a vysokovýkonný Java kód, a hluboké, často testované téma, které odlišuje kompetentní od zkušených vývojářů.