Java માં multithreading કેવી રીતે કામ કરે છે?

Question

Accepted Answer

**Multithreading** એ Java પ્રોગ્રામને બહુવિધ threads સાથે વધુ દોડવા દે છે, જે parallelism (બહુવિધ CPU cores નો ઉપયોગ) અને responsiveness (કામ કર્યા વિના અવરોધ વિના) ને સક્ષમ કરે છે. Java માં first-class thread support છે — પરંતુ shared mutable state જટિલતા (race conditions) પરિચય આપે છે જે સાવધાનીથી સંચાલિત થવું જોઈએ. ## 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); ``` **મુખ્ય સમસ્યા:** `start()` ને કૉલ કરો (નવો thread સ્પોન કરે છે), `run()` નહીં (જે માત્ર વર્તમાન thread પર synchronously કોડ ચલાવે છે). ## મુખ્ય સમસ્યા: 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++` વાસ્તવમાં ત્રણ ક્રિયાઓ છે (read, increment, write). જ્યારે threads interleave થાય, અપડેટ્સ ખોવાઈ જાય છે — એક **race condition**. આ concurrency ની કેન્દ્રીય સમસ્યા છે: shared mutable state જે બહુવિધ threads દ્વારા સંકલન વિના એક્સેસ કરવામાં આવે છે. ## Safe 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 ``` ## આધુનિક અભિગમ: કાચા 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 ``` ## તે શા માટે મહત્વનું છે Multithreading Java પ્રોગ્રામને બહુવિધ cores નો ઉપયોગ કરવા અને પ્રતિક્રિયાશીલ રહેવા દે છે, પણ તે concurrency ના સૌથી મુશ્કેલ ક્ષેત્રોમાંનું એક પણ છે — unsynchronized shared mutable state માંથી **race conditions** અનિયમિત, પુનરુત્પાદન કરવામાં મુશ્કેલ bugs નું કારણ બને છે. threads કેવી રીતે કામ કરે છે તે સમજવું (`start()` વિરુદ્ધ `run()`), મુખ્ય race-condition સમસ્યા (શા માટે `count++` સુરક્ષિત નથી), અને સુરક્ષા સુનિશ્ચિત કરવા માટે આવશ્યક સાધનો (`synchronized`, atomic classes, concurrent collections, immutability) સાચો concurrent code લખવા માટે આવશ્યક છે. આધુનિક શ્રેષ્ઠ પ્રાર્થના કાચા thread સંચાલનના બદલે ઉચ્ચ-સ્તરીય abstractions (ExecutorService, CompletableFuture, virtual threads) ને પસંદ કરે છે. યો server-side અને high-performance Java માટે નિર્ણાયક જ્ઞાન છે, અને એક ઊંડો, વારંવાર-પરીક્ષણ કરવામાં આવતો topic જે સક્ષમ વિશેષજ્ઞ developers થી અલગ પાડે છે.