Hogyan működik a multithreading a Java-ban?

Question

Accepted Answer

**A multithreading** lehetővé teszi, hogy egy Java program több szálat futtasson egyidejűleg, ami párhuzamosságot (több CPU mag felhasználása) és reakciókészséget (munkavégzés blokkolás nélkül) biztosít. A Java első osztályú szál támogatással rendelkezik — azonban a megosztott változtatható állapot komplexitást vezet be (versenyhelyzetek), amelyet gondosan kell kezelni. ## Szálak létrehozása ```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); ``` **Gyakori hiba:** hívd meg a `start()` metódust (új szál indítása), ne a `run()` metódust (amely csak szinkron módon futtatja a kódot az aktuális szálon). ## Az alapvető probléma: versenyhelyzetek ```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! ``` A `count++` valójában három művelet (olvasás, inkrementálás, írás). Ha szálak átfedésben futnak, a frissítések elvesznek — ez egy **versenyhelyzet**. Ez az egyidejűség központi kihívása: megosztott változtatható állapot, amelyet több szál koordináció nélkül használ. ## Megoldások a biztonságos megosztott állapotra ```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) ``` ## Szálkoordináció ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## A modern megközelítés: ne kezelje közvetlenül a szálakat ```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 ``` ## Miért fontos A multithreading lehetővé teszi, hogy Java programok több magot használjanak és reagálékonyak maradjanak, de ez egyben az egyik legnehezebb terület is — a szinkronizálatlan megosztott változtatható állapotból eredő **versenyhelyzetek** időszakos, nehezen reprodukálható hibákat okoznak. Annak megértése, hogy hogyan működnek a szálak (`start()` vs `run()`), az alapvető versenyhelyzet probléma (miért nem biztonságos a `count++`), és az eszközök a biztonság biztosítása érdekében (`synchronized`, atomikus osztályok, egyidejű gyűjtemények, megváltoztathatatlanság) elengedhetetlen a helyes egyidejű kód írásához. A modern ajánlott gyakorlat magasabb szintű absztrakciókat részesít előnyben (ExecutorService, CompletableFuture, virtuális szálak) a nyers szálkezelés helyett. Ez kritikus fontosságú tudás a szerver oldali és nagy teljesítményű Java-hoz, valamint egy mélyen vizsgált téma, amely elválasztja a kompetens fejlesztőket a szakértőktől.