Jak działa multithreading w Javie?

Question

Accepted Answer

**Multithreading** pozwala programowi Java na uruchamianie wielu wątków jednocześnie, umożliwiając równoleglosć (wykorzystanie wielu rdzeni CPU) i responsywność (wykonywanie pracy bez blokowania). Java ma wbudowaną obsługę wątków — ale współdzielony, zmienny stan wprowadza złożoność (race conditions), którą należy ostrożnie zarządzać. ## Tworzenie wątków ```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); ``` **Główna pułapka:** wywołaj `start()` (tworzy nowy wątek), a nie `run()` (co tylko uruchamia kod w bieżącym wątku synchronicznie). ## Problem fundamentalny: 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++` to faktycznie trzy operacje (czytaj, inkrementuj, zapisz). Gdy wątki przeplatają się, aktualizacje są tracone — **race condition**. To jest główne wyzwanie współbieżności: współdzielony zmienny stan dostępny dla wielu wątków bez koordynacji. ## Rozwiązania dla bezpiecznego stanu współdzielonego ```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) ``` ## Koordynacja wątków ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## Nowoczesne podejście: nie zarządzaj surowymi wątkami ```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 ``` ## Dlaczego to ważne Multithreading umożliwia programom Java wykorzystanie wielu rdzeni i pozostanie responsywnym, ale jest to również jedna z najtrudniejszych dziedzin do prawidłowego wykonania — **race conditions** z niesynchronizowanym współdzielonym zmiennym stanem powodują sporadyczne, trudne do odtworzenia błędy. Zrozumienie, jak działają wątki (`start()` vs `run()`), problem fundamentalny race conditions (dlaczego `count++` nie jest bezpieczny) oraz narzędzia zapewniające bezpieczeństwo (`synchronized`, klasy atomowe, kolekcje współbieżne, niezmienność) jest niezbędne do pisania poprawnego kodu współbieżnego. Nowoczesna praktyka faworyzuje abstrakcje wyższego poziomu (ExecutorService, CompletableFuture, wirtualne wątki) zamiast zarządzania surowymi wątkami. To jest krytyczna wiedza dla Javy po stronie serwera i o wysokiej wydajności, oraz głębokie, często testowane zagadnienie, które odróżnia kompetentnych od ekspertów."},