Java இல் multithreading எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

**Multithreading** Java நிரலை பல தேவடியாக ஒரே நேரத்தில் இயக்க அனுமதிக்கிறது, இது இணையமுற்ற செயல்பாடு (பல CPU மூல்களைப் பயன்படுத்த) மற்றும் பணொடுக்கம் (தடையின்றி வேலை செய்ய) ஆகியவற்றை செயல்படுத்துகிறது. Java தேவடிகளுக்கு முதல் தர ஆதரவைக் கொண்டுள்ளது — ஆனால் பகிரப்பட்ட மாறக்கூடிய நிலை சிக்கலை (race நிலைமைகள்) அறிமுகப்படுத்துகிறது, இது கவனமாக நிர்வகிக்கப்பட வேண்டும். ## தேவடிகளை உருவாக்குதல் ```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()` ஐ அல்ல (இது தற்போதைய தேவடியில் குறியீட்டை ஒத்திசைப்பாக இயக்குகிறது). ## மূல சிக்கல்: race நிலைமைகள் ```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++` உண்மையில் மூன்று செயல்பாடுகள் (படி, கூட்டு, எழுது). தேவடிகள் முறுக்கும்போது, புதுப்பிப்புகள் இழக்கப்படுகின்றன — ஒரு **race நிலை**. இது ஒரே நேரத்தன்மையின் மূல சவாலு: பல தேவடிகளால் அணுகப்படும் பகிரப்பட்ட மாறக்கூடிய நிலை ஒருங்கிணைப்பு இல்லாமல். ## பாதுகாப்பான பகிரப்பட்ட நிலைக்கான தீர்வுகள் ```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 நிரல்களை பல மூல்களைப் பயன்படுத்தவும் பணொடுக்கமாக இருக்கவும் செயல்படுத்துகிறது, ஆனால் இது சரியாக செய்ய மிகவும் கடினமான பகுதிகளுள் ஒன்றாகும் — ஒத்திசைக்கப்படாத பகிரப்பட்ட மாறக்கூடிய நிலையிலிருந்து **race நிலைமைகள்** இடைப்பட்ட, இனப்பெருக்கம் கடினமான பிழைகளை ஏற்படுத்துகின்றன. தேவடிகள் எவ்வாறு செயல்படுகின்றன (`start()` vs `run()`), race நிலையின் மூல சிக்கல் (ஏன் `count++` பாதுகாப்பு அல்ல) மற்றும் பாதுகாப்பை உறுதி செய்வதற்கான கருவிகள் (`synchronized`, atomic வகுப்புகள், concurrent சேகரணை, மாறாத) ஆகியவற்றைப் புரிந்துகொள்வது சரியான ஒரே நேரத்தன்மை குறியீட்டை எழுதுவதற்கு அপরிহார்யமாகும். आधुनिक best practice உயர் நிலையான abstractions (ExecutorService, CompletableFuture, virtual தேவடிகள்) கச்சா தேவடி நிர்வாகத்திற்கு மேலே பயன்படுத்துகிறது। இது sundar-பக்கம் மற்றும் உচ்च-செயல்திறன் Java க்கான গুருத்வபூர்ண அறிவு, மற்றும் ஒரு ஆழமான, அடிக்கடி-சோதிக்கப்படும் பாடம், இது சமர்த்தமான விருத்திக்கலை்வாலிகளிலிருந்து நிபுணத வளர்த்தி வகுக்கிறது।