मल्टीथ्रेडिंग Java प्रोग्रामला एकाच वेळी अनेक थ्रेड चालवू देते, ज्यामुळे समांतरता (अनेक CPU कोर वापरून) आणि प्रतिक्रियाशीलता (कामे अवरोधित न करता) शक्य होते. Java मध्ये थ्रेडला प्रथम श्रेणीचा समर्थन आहे — परंतु सामायिक बदलणारी स्थिती जटिलता (रेस कंडिशन) आणते जी काळजीपूर्वक व्यवस्थापित करावी लागते.
() -> System.out.println( + Thread.currentThread().getName());
(task);
t.start();
Executors.newFixedThreadPool();
executor.submit(task);
महत्वाचा बिंदू: start() (नवीन थ्रेड तयार करते) कॉल करा, run() नाही (जो केवळ वर्तमान थ्रेडवर कोड सिंक्रोनसली चालवते).
// ❌ 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++ खरेतर तीन ऑपरेशन आहे (वाचन, वाढ, लिहिणे). जेव्हा थ्रेड एकमेकांच्या मध्ये येतात, तेव्हा अपडेट हरले जातात — रेस कंडिशन. हे समवर्तनताचे मूळ आव्हान आहे: सामायिक बदलणारी स्थिती ज्यात अनेक थ्रेड समन्वय न करता प्रवेश करतात.
// 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<String, Integer> map = new ConcurrentHashMap<>();
// 4. immutability — immutable objects are inherently thread-safe (nothing to corrupt)
t.join(); // wait for thread t to finish
Thread.sleep(1000); // pause the current thread
// also: wait()/notify(), CountDownLatch, locks, etc. for coordination
✓ 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
मल्टीथ्रेडिंग Java प्रोग्रामला अनेक कोर वापरू देते आणि प्रतिक्रियाशील राहायला मदत करते, परंतु हे अवरोधित न झालेल्या सामायिक बदलणारी स्थितीतून रेस कंडिशन समान कठीण क्षेत्र आहे जे अविश्वसनीय, पुनरुत्पादन करणे कठीण बग्ज निर्माण करतात.
थ्रेड कसे कार्य करतात (start() vs run()), मूळ रेस कंडिशन समस्या (का count++ सुरक्षित नाही), आणि सुरक्षा सुनिश्चित करण्यासाठी साधने (synchronized, अणुवर्ग, समवर्ती संग्रह, अपरिवर्तनीयता) समजून घेणे हे योग्य समवर्ती कोड लिहिण्यासाठी आवश्यक आहे.
आधुनिक सर्वोत्तम प्रथा कच्च्या थ्रेड व्यवस्थापनापेक्षा उच्च-स्तरीय अमूर्तकरणला (ExecutorService, CompletableFuture, आभासी थ्रेड) पसंद करते.
हे सर्व-बाजूची आणि उच्च-कार्यक्षमता Java साठी महत्वाचे ज्ञान आहे, आणि हा एक गहन, वारंवार परीक्षित विषय आहे जो सक्षम विकासकांना तज्ञ विकासकांपासून वेगळे करतो.