Java में multithreading कैसे काम करती है?

Question

Accepted Answer

**Multithreading** एक Java program को कई threads को समवर्ती रूप से चलाने देती है, जिससे parallelism (कई CPU cores का उपयोग) और responsiveness (block किए बिना काम करना) संभव होती है। 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()` को call करें (एक नया thread spawn करता है), `run()` को नहीं (जो केवल current thread पर code को 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++` वास्तव में तीन operations हैं (read, increment, write)। जब threads interleave होते हैं, तो updates खो जाते हैं — एक **race condition**। यह concurrency की केंद्रीय चुनौती है: कई threads द्वारा बिना समन्वय के access किया गया shared mutable state। ## सुरक्षित 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 समन्वय ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## आधुनिक दृष्टिकोण: 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 ``` ## यह क्यों महत्वपूर्ण है Multithreading Java programs को कई cores का उपयोग करने और responsive बने रहने में सक्षम बनाती है, लेकिन यह सही करने के लिए सबसे कठिन क्षेत्रों में से एक भी है — unsynchronized shared mutable state से **race conditions** रुक-रुक कर होने वाले, पुनरुत्पादन में कठिन bugs उत्पन्न करती हैं। यह समझना कि threads कैसे काम करते हैं (`start()` बनाम `run()`), मूल race-condition समस्या (`count++` सुरक्षित क्यों नहीं है), और सुरक्षा सुनिश्चित करने के उपकरण (`synchronized`, atomic classes, concurrent collections, immutability) सही concurrent code लिखने के लिए आवश्यक है। आधुनिक best practice raw thread प्रबंधन की तुलना में higher-level abstractions (ExecutorService, CompletableFuture, virtual threads) को प्राथमिकता देती है। यह server-side और high-performance Java के लिए महत्वपूर्ण ज्ञान है, और एक गहरा, अक्सर परीक्षित विषय है जो सक्षम developers को expert developers से अलग करता है।