Multithreading ya aiki ta Java ta nawa?

Question

Accepted Answer

**Multithreading** yana bai da damar program na Java ya gudu thread masu yawa a lokaci gida, wanda ya aiki don parallelism (amfani da CPU cores da yawa) da responsiveness (aiki ba tare da dakatar da ba). Java yana da sakandare thread support — amma shared mutable state yana gabatar da hadaddiyya (race conditions) wanda dole a sarrafa shi sosai. ## Ƙirƙirar threads ```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); ``` **Mahimmin tunani:** kira `start()` (yana haifar da sabuwar thread), ba `run()` ba (wanda kawai ya gudu code akan current thread synchronously). ## Babbar matsalar: 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++` a zahiri aiki ne uku (karanta, dagirta, rubutu). Lokacin da threads suka danganta, sabuntawa suka rasa — **race condition**. Wannan shine abubuwan da ke damowa na zamantakewa: shared mutable state da ake bukata da thread masu yawa ba tare da haɗin gida ba. ## Mafitoni don secure shared state ```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) ``` ## Thread coordination ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## Sabuwan hanya: kada aiwatar da raw threads ```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 ``` ## Me ya sa ya matuƙa Multithreading yana bai da damar program na Java ya amfani da core masu yawa da zama responsive, amma kuma yana ƙarang mafi tsanani a saurin samun daidai — **race conditions** daga unsynchronized shared mutable state suna haifar da kuɗi masu sakaci, da wahala a sake gina. Tunani ta yaya threads ya aiki (`start()` da `run()`), matsalar race-condition ta gida (me ya sa `count++` ba safe ba), da kayan aiki don tabbatar da aminci (`synchronized`, atomic classes, concurrent collections, immutability) ya zama mahimmi don rubutu daidai concurrent code. Sabuwan hanya da aka fi amfani tashe-taste horarwa matakin gida (ExecutorService, CompletableFuture, virtual threads) akan raw thread management. Wannan ilimi mai mahimmanci ne don server-side da Java mai girma, da zafi, matakin gida da ake gwada sau da yawa wanda ke bambanta da ƙwararru mula ga masu ƙwararru.