Java मा multithreading कसरी काम गर्छ?

Question

Accepted Answer

**Multithreading** ले Java प्रोग्रामलाई एकै पटक बहु threads चलाउन दिन्छ, जसले parallelism (बहु CPU cores को प्रयोग) र responsiveness (काम बिना रोकेर गर्न) सक्षम गर्छ। Java मा first-class thread support छ — तर साझा परिवर्तनशील 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 मा सिङ्क्रोनसली चलाउँछ)। ## मूल समस्या: 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 हुन्छन्, updates हराउँछन् — एक **race condition**। यो concurrency को केन्द्रीय चुनौती हो: समन्वय बिना बहु threads द्वारा साझा परिवर्तनशील state पहुँच गर्दै। ## सुरक्षित साझा 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 ``` ## आधुनिक दृष्टिकोण: कच्चा 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 प्रयोग गर्न र responsive रहन सक्षम गर्छ, तर यो concurrency को सबैभन्दा कठिन क्षेत्रमा पनि एक हो — असुरक्षित साझा परिवर्तनशील state बाट **race conditions** ले intermittent, कठिन-पुनर्उत्पादन गर्न सकिने बगहरू निर्माण गर्छन्। Threads कसरी काम गर्छन् (`start()` बनाम `run()`), मूल race-condition समस्या (किन `count++` सुरक्षित छैन), र सुरक्षा सुनिश्चित गर्न को उपकरणहरू (`synchronized`, atomic classes, concurrent collections, immutability) समझना सही concurrent code लेख्न आवश्यक छ। आधुनिक best practice ले कच्चा thread व्यवस्थापन भन्दा उच्च-स्तरीय abstractions (ExecutorService, CompletableFuture, virtual threads) लाई प्राथमिकता दिन्छ। यो server-side र high-performance Java को लागि गुरुत्वपूर्ण ज्ञान हो, र गहिरो, बारम्बार-परीक्षण गरिने विषय जो सक्षम र विशेषज्ञ developers को अलग गर्छ।