Java లో multithreading ఎలా పనిచేస్తుంది?

Question

Accepted Answer

**Multithreading** Java ప్రోగ్రామ్‌ను బహుళ థ్రెడ్‌లను ఏకకాలంలో అమలు చేయడానికి అనుమతిస్తుంది, సమాంతరవాదం (బహుళ CPU కోర్‌లను ఉపయోగించడం) మరియు ప్రతిస్పందన (నిరోధం లేకుండా పని చేయడం) ను సక్షమం చేస్తుంది. Java థ్రెడ్‌ల కోసం ఫర్స్ట్-క్లాస్ సపోర్టు కలిగి ఉంది — అయితే భాగస్వామ్య మార్పుశీల స్థితి సంక్లిష్టతను (రేస్ పరిస్థితులు) నిర్మాణం చేస్తుంది, అది జాగ్రత్తగా నిర్వహించాలి. ## థ్రెడ్‌లను సృష్టించడం ```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()` (నতुने థ్రెడ్‌ని సృష్టిస్తుంది) ని కాల్ చేయండి, `run()` (ఇది కరెంట్ థ్రెడ్‌లో కోడ్‌ని సమకాలీనంగా అమలు చేస్తుంది) కాదు. ## ప్రధాన సమస్య: రేస్ పరిస్థితులు ```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++` నిజానికి మూడు ఆపరేషన్‌లు (చదువు, పెంచు, రాయు). థ్రెడ్‌లు ఇంటర్‌లీవ్ చేయబడినప్పుడు, అప్‌డేట్‌లు కోల్పోతాయి — ఒక **రేస్ పరిస్థితి**. ఇది సమకాలీనత యొక్క ప్రధాన సవాలు: సమన్వయం లేకుండా బహుళ థ్రెడ్‌ల ద్వారా ప్రాప్యత చేయబడిన భాగస్వామ్య మార్పుశీల స్థితి. ## సురక్షితమైన భాగస్వామ్య స్థితి కోసం పరిష్కారాలు ```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) ``` ## థ్రెడ్ సమన్వయం ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## ఆధునిక విధానం: ముడి థ్రెడ్‌లను నిర్వహించవద్దు ```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 ప్రోగ్రామ్‌లను బహుళ కోర్‌లను ఉపయోగించడానికి మరియు ప్రతిస్పందనశీలంగా ఉండటానికి సక్షమం చేస్తుంది, కానీ ఇది కూడా సరిగ్గా చేయడానికి చాలా కష్టమైన రంగాలలో ఒకటి — అసమకాలీన భాగస్వామ్య మార్పుశీల స్థితి నుండి **రేస్ పరిస్థితులు** విరామ, పునరుత్పత్తి చేయడానికి కష్టమైన బగ్‌లకు కారణమవుతాయి. థ్రెడ్‌లు ఎలా పనిచేస్తాయి (`start()` vs `run()`), రేస్-పరిస్థితి యొక్క ప్రధాన సమస్య (ఎందుకు `count++` సురక్షితమైనది కాదు) మరియు సురక్షా సాధనాలు (`synchronized`, అటామిక్ క్లాసెస్, సమకాలీన సేకరణలు, మార్పుచేయనీయતత) ను అర్థం చేసుకోవడం సరైన సమకాలీన కోడ్ రాయడానికి ముఖ్యమైనది. ఆధునిక బెస్ట్ ప్రాక్టీస్ ముడి థ్రెడ్ నిర్వాహణ కంటే ఎక్కువ-స్థాయి సంగ్రహణలను (ExecutorService, CompletableFuture, వర్చువల్ థ్రెడ్‌లు) ఇష్టపడుతుంది. ఇది సర్వర్-సైడ్ మరియు అధిక-పనితీరు Java కోసం క్లిష్టమైన జ్ఞానం మరియు లోతైన, తరచుగా-పరీక్షించిన విషయం, ఇది సమర్థ నుండి నిపుణ డెవలపర్‌లను వేరుచేస్తుంది.