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 ਵਿੱਚ ਸਿੰਕ੍ਰੋਨਸਲੀ ਚਲਾਉਂਦਾ ਹੈ)। ## ਮੁੱਖ ਸਮਸਿਆ: 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 ਦੁਆਰਾ ਪਹੁੰਚ ਕੀਤੀ ਗਈ 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 ਪ੍ਰੋਗ੍ਰਾਮਾਂ ਨੂੰ ਮਲਟੀਪਲ cores ਦਾ ਉਪਯੋਗ ਕਰਨ ਅਤੇ responsive ਰਹਿਣ ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦਾ ਹੈ, ਪਰ ਇਹ ਵੀ ਕਠਤਰ ਖੇਤਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ ਜਿਸ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਕਰਨਾ ਹੈ — unsynchronized shared mutable state ਤੋਂ **race conditions** intermittent, ਮੁਸ਼ਕਲ-ਦੁਬਾਰਾ-ਤਿਆਰ ਕੀਤੇ ਜਾ ਸਕਣ ਵਾਲੇ bugs ਦਾ ਕਾਰਨ ਬਣਦੇ ਹਨ। ਇਹ ਸਮਝਣਾ ਕਿ threads ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ (`start()` ਬਨਾਮ `run()`), race conditions ਦੀ ਮੁੱਖ ਸਮੱਸਿਆ (ਕਿਉਂ `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 ਨੂੰ ਵੱਖ ਕਰਦਾ ਹੈ।