Multithreading inafanyaje kazi katika Java?

Question

Accepted Answer

**Multithreading** inaruhusu programu ya Java kueneza nyuzi nyingi wakati mmoja, na kuwezesha parallelism (kutumia cores nyingi za CPU) na responsiveness (kufanya kazi bila kukamatia). Java ina support ya daraja la kwanza kwa nyuzi — lakini hali ya pamoja inayobadilika kuanzisha utata (race conditions) ambayo lazima ikadimiwe kwa makini. ## Kuunda nyuzi ```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); ``` **Kosa kubwa:** ita `start()` (huanza nyuzi mpya), si `run()` (ambayo tu hueneza nambari kwenye nyuzi ya sasa kwa njia ya synchronized). ## Tatizo la msingi: 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++` ni kweli operesheni tatu (kusoma, kuongeza, kuandika). Wakati nyuzi zinapoingiliana, updates zinapopotea — **race condition**. Hii ndiyo changamoto ya msingi ya concurrency: hali ya pamoja inayobadilika kwa nyuzi nyingi bila uratibu. ## Suluhisho kwa hali ya pamoja salama ```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) ``` ## Uratibu wa nyuzi ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## Mbinu ya sasa: usizigize nyuzi za kawaida ```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 ``` ## Kwa nini ni muhimu Multithreading inaruhusu programu za Java kutumia cores nyingi na kuendelea na responsiveness, lakini pia ni mojawapo ya maeneo magumu zaidi — **race conditions** kutoka hali ya pamoja isiyojumuishwa nayabadilika husababisha hitilafu za intermittent na ngumu kukamatia. Kuelewa jinsi nyuzi zinavyofanya kazi (`start()` vs `run()`), tatizo la msingi la race condition (kwa nini `count++` si salama) na zana za kuhakikisha usalama (`synchronized`, atomic classes, concurrent collections, immutability) ni muhimu kwa kuandika nambari sahihi ya concurrent. Mbinu ya sasa ya best practice inapendelea abstractions ya juu (ExecutorService, CompletableFuture, virtual threads) badala ya usimamizi wa nyuzi za kawaida. Hii ni maarifa ya muhimu kwa ujamaa wa server-side na juu-performance Java, na kwa msingi, mada ya sifa mara kwa mara ambayo hutenganisha watendaji wenye kiwango na watendaji wa kitaalam.