Java میں multithreading کیسے کام کرتی ہے؟

Question

Accepted Answer

**Multithreading** ایک Java پروگرام کو متعدد threads کو بیک وقت چلانے کی اجازت دیتی ہے، جو parallelism (متعدد CPU cores استعمال کرتے ہوئے) اور responsiveness (کام کو بغیر blocking کے کرنے) کو ممکن بناتی ہے۔ 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 بناتا ہے)، `run()` نہیں (جو صرف موجودہ 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 کے ذریعے accessed shared mutable state بغیر coordination کے۔ ## 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 ``` ## جدید طریقہ: raw threads کو manage نہ کریں ```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 رہنے کی صلاحیت دیتی ہے، لیکن یہ بھی سب سے مشکل شعبوں میں سے ایک ہے — **race conditions** unsynchronized shared mutable state سے intermittent، hard-to-reproduce bugs پیدا کرتی ہیں۔ یہ سمجھنا کہ threads کیسے کام کرتے ہیں (`start()` بمقابلہ `run()`)، race-condition کا بنیادی مسئلہ (کیوں `count++` محفوظ نہیں ہے)، اور safety کے لیے tools (`synchronized`، atomic classes، concurrent collections، immutability) صحیح concurrent code لکھنے کے لیے ضروری ہے۔ جدید best practice raw thread management کے بجائے higher-level abstractions (ExecutorService، CompletableFuture، virtual threads) کو ترجیح دیتی ہے۔ yہ server-side اور high-performance Java کے لیے اہم علم ہے، اور ایک گہرا، بار بار test ہونے والا موضوع ہے جو capable سے expert developers کو الگ کرتا ہے۔