Synchronization

Synchronization क्यों

जब कई threads एक ही data साझा करें, वे एक-दूसरे में दख़ल देकर गलत परिणाम दे सकते हैं। Synchronization पक्का करता है कि एक बार में सिर्फ़ एक thread साझा data इस्तेमाल करे, उसे सुरक्षित और संगत रखकर। यह multithreaded programs में ज़रूरी है।

Race condition समस्या

class Counter {
    int count = 0;
    void increment() { count++; }   // thread-safe नहीं
}
// अगर दो threads साथ increment() call करें,
// कुछ increments खो सकते हैं, गलत total देकर।

count++ सरल दिखता है, पर यह असल में read-add-write है। अगर दो threads इसे एक साथ करें, एक update दूसरे को overwrite कर सकता है — एक race condition जो counts खोता है।

Synchronized method

class Counter {
    int count = 0;
    synchronized void increment() {   // अब thread-safe
        count++;
    }
}

Method को synchronized जोड़ना मतलब एक बार में सिर्फ़ एक thread इसे चला सकता है। बाक़ी अपनी बारी का इंतज़ार करते हैं, तो हर increment सही गिना जाता है।

Synchronized block

void increment() {
    // ... दूसरा काम जिसे lock की ज़रूरत नहीं ...
    synchronized (this) {     // सिर्फ़ यह हिस्सा lock
        count++;
    }
}

Synchronized block सिर्फ़ चुने section को lock करता है, पूरी method को नहीं। यह ज़्यादा सटीक है: आप सिर्फ़ साझा-data हिस्सा lock करते हैं, बाक़ी को बेहतर performance को स्वतंत्र चलने देकर।

Lock कैसे काम करता है

हर object में एक आंतरिक lock (monitor) होता है। जब thread synchronized method या block में घुसता है, यह उस object का lock हासिल करता है। वही lock चाहने वाले अन्य threads को छूटने तक इंतज़ार करना पड़ता है — जो synchronized code ख़त्म होने पर अपने-आप होता है।

कब synchronize करें

• साझा, बदलने योग्य data कई threads द्वारा access — इसे synchronize कीजिए।
• Read-only data — कोई synchronization नहीं चाहिए।
• Locked sections छोटे रखिए — speed को सिर्फ़ जो सुरक्षित होना चाहिए वो lock कीजिए।

आधुनिक Java आम मामलों को ConcurrentHashMap और java.util.concurrent classes जैसे उच्च-स्तरीय tools भी देती है।

आम गलतियाँ

• साझा data synchronize न करना। Race conditions और गलत परिणामों की ओर ले जाता है।
• सब कुछ synchronize करना। Program धीमा करता है — सिर्फ़ ज़रूरी lock कीजिए।
• अलग objects पर lock करना। Threads को सुरक्षित होने को वही lock object साझा करना चाहिए।
• यह भूलना read-modify-write atomic नहीं। count++ को भी सुरक्षा चाहिए।

सारांश

• Synchronization threads के बीच साझा data की रक्षा करता है।
• Race condition तब data corrupt करता है जब threads उसे साथ बदलें।
• synchronized एक बार में सिर्फ़ एक thread को method या block चलाने देता है।
• Synchronized block एक छोटा, सटीक section lock करता है।
• Locked sections छोटे रखिए और सिर्फ़ साझा, बदलने योग्य data की रक्षा कीजिए।

आगे, threads दोहराइए multithreading में, या thread-safe map इस्तेमाल कीजिए HashMap vs Hashtable से।