Semaphore: यह क्या है, कैसे काम करता है और थ्रेड सिंक्रोनाइज़ेशन में उपयोग

Semaphore क्या है?

Semaphore एक सिंक्रोनाइज़ेशन प्रिमिटिव है जो एक साझा संसाधन तक पहुँच को नियंत्रित करने के लिए काउंटर का उपयोग करता है। यह अवधारणा एड्सगर डेक्सट्रा द्वारा 1965 में प्रस्तावित की गई थी और ऑपरेटिंग सिस्टम में सभी आधुनिक सिंक्रोनाइज़ेशन तंत्रों की नींव बनी।

परिभाषा और उद्देश्य

सेमाफोर दो परमाणु संक्रियाओं वाला एक पूर्णांक चर है: wait (acquire) और signal (release)। wait संक्रिया काउंटर को घटाती है, जबकि signal इसे बढ़ाती है। जब काउंटर शून्य तक पहुँचता है, तो wait को कॉल करने वाला थ्रेड तब तक ब्लॉक हो जाता है जब तक कोई दूसरा थ्रेड signal निष्पादित नहीं करता।

सेमाफोर का मुख्य उद्देश्य क्रिटिकल सेक्शन को कई थ्रेड्स के एक साथ पहुँच से बचाना है। म्यूटेक्स के विपरीत, सेमाफोर को मालिक थ्रेड से बंधन की आवश्यकता नहीं होती, जो इसे समन्वय कार्यों की व्यापक श्रृंखला के लिए उपयुक्त बनाता है।

इतिहास और सैद्धांतिक आधार

सेमाफोर की अवधारणा THE ऑपरेटिंग सिस्टम के संदर्भ में उत्पन्न हुई, जो Technische Hogeschool Eindhoven में विकसित किया गया था। डेक्सट्रा ने सेमाफोर को एक गणितीय अमूर्तता के रूप में औपचारिक रूप दिया, किसी भी सिंक्रोनाइज़ेशन प्रिमिटिव को लागू करने के लिए इसकी पर्याप्तता साबित की।

सेमाफोर कैसे काम करता है?

सेमाफोर तंत्र दो परमाणु संक्रियाओं और एक आंतरिक प्रतीक्षा कतार पर आधारित है। जब acquire कॉल किया जाता है, थ्रेड काउंटर मान की जाँच करता है और या तो निष्पादन जारी रखता है या संसाधन मुक्त होने तक ब्लॉक हो जाता है।

काउंटर और परमाणु संक्रियाएँ

सेमाफोर बनाते समय, अनुमति काउंटर का प्रारंभिक मान निर्धारित किया जाता है। प्रत्येक acquire कॉल काउंटर को 1 से घटाता है। यदि इसके बाद काउंटर ऋणात्मक हो जाता है, तो थ्रेड ब्लॉक हो जाता है। release संक्रिया काउंटर को बढ़ाती है और प्रतीक्षा कर रहे थ्रेड्स में से एक को जगाती है।

import java.util.concurrent.Semaphore

val semaphore = Semaphore(3)

fun accessResource() {
    semaphore.acquire()
    try {
        println("${Thread.currentThread().name} काम कर रहा है")
    } finally {
        semaphore.release()
    }
}

प्रतीक्षा कतार और शेड्यूलिंग

जब कोई थ्रेड शून्य काउंटर के साथ acquire कॉल करता है, तो OS उसे सेमाफोर की FIFO कतार में रखता है। थ्रेड BLOCKED अवस्था में चला जाता है, CPU समय का उपभोग नहीं करता। release कॉल के बाद, कतार में पहला थ्रेड RUNNABLE अवस्था में जाता है और संसाधन तक पहुँच प्राप्त करता है।

सेमाफोर के प्रकार

सिंक्रोनाइज़ेशन सिद्धांत में सेमाफोर के दो मुख्य प्रकार प्रतिष्ठित हैं: बाइनरी और काउंटिंग। प्रकार का चयन संसाधनों तक पहुँच प्रबंधन के विशिष्ट कार्य पर निर्भर करता है।

बाइनरी सेमाफोर (Binary Semaphore)

बाइनरी सेमाफोर केवल मान 0 और 1 लेता है। व्यवहार में, यह म्यूटेक्स जैसा दिखता है, लेकिन स्वामित्व आवश्यकता के बिना — कोई भी थ्रेड release निष्पादित कर सकता है। ऐसे सेमाफोर थ्रेड्स के बीच तैयारी फ्लैग और घटनाओं को लागू करने के लिए सुविधाजनक हैं।

val ready = Semaphore(0)

fun producer() {
    Thread.sleep(1000)
    ready.release()
}

fun consumer() {
    ready.acquire()
    println("डेटा तैयार है")
}

काउंटिंग सेमाफोर (Counting Semaphore)

काउंटिंग सेमाफोर कोई भी गैर-ऋणात्मक मान ले सकता है। इसका उपयोग समान संसाधनों के पूल को प्रबंधित करने के लिए किया जाता है जहाँ कई इंस्टेंस उपलब्ध हों। उदाहरण के लिए, 5 नेटवर्क कनेक्शन का पूल: प्रत्येक acquire एक कनेक्शन लेता है, release इसे पूल में वापस करता है।

काउंटिंग सेमाफोर बाहरी सेवाओं तक पहुँच की दर सीमित करने और थ्रेड पूल लागू करने के लिए अपरिहार्य हैं। वे मैन्युअल थ्रेड प्रबंधन के बिना समांतरता की डिग्री को सटीक रूप से नियंत्रित करने की अनुमति देते हैं।

Semaphore बनाम Mutex

डेवलपर्स अक्सर सेमाफोर और म्यूटेक्स को भ्रमित करते हैं, हालाँकि इनके बीच मूलभूत अंतर हैं। इन अंतरों को समझना किसी प्रोजेक्ट में सही सिंक्रोनाइज़ेशन तंत्र चुनने के लिए अत्यंत महत्वपूर्ण है।

स्वामित्व सिद्धांत

मुख्य अंतर स्वामित्व अवधारणा है। म्यूटेक्स हमेशा जानता है कि किस थ्रेड ने इसे प्राप्त किया है, और केवल वही थ्रेड इसे मुक्त कर सकता है। सेमाफोर का कोई मालिक नहीं है: कोई भी थ्रेड बिना acquire कॉल किए release कॉल कर सकता है। यह म्यूटेक्स को डेटा सुरक्षा के लिए अधिक सुरक्षित और सेमाफोर को समन्वय के लिए अधिक लचीला बनाता है।

प्रदर्शन और उपयोग परिदृश्य

व्यवहार में, म्यूटेक्स सामान्य परिदृश्यों के लिए अनुकूलन के कारण सरल पारस्परिक बहिष्करण के लिए तेज़ है। सेमाफोर को काउंटर बनाए रखने के लिए अतिरिक्त ओवरहेड की आवश्यकता होती है। हालाँकि, समांतरता को सीमित करने या उत्पादक-उपभोक्ता पैटर्न को लागू करने के लिए, सेमाफोर अपरिहार्य है।

मोबाइल डेवलपमेंट में Semaphore

मोबाइल एप्लिकेशन डेवलपमेंट में, Semaphore का उपयोग सीमित संसाधनों तक पहुँच प्रबंधित करने के लिए किया जाता है: नेटवर्क कनेक्शन, फ़ाइलें, डेटाबेस और हार्डवेयर घटक। आधुनिक प्लेटफ़ॉर्म सुविधाजनक अंतर्निहित कार्यान्वयन प्रदान करते हैं।

सर्वर कनेक्शन पूल

एक विशिष्ट उपयोग मामला HTTP कनेक्शन पूल है। एक एप्लिकेशन सर्वर को एक साथ 4 से अधिक अनुरोध नहीं भेज सकता क्योंकि प्रदाता का API समांतरता को सीमित करता है। प्रारंभिक मान 4 वाला सेमाफोर सुनिश्चित करता है कि किसी भी भार के तहत, समवर्ती अनुरोधों की संख्या सीमा से अधिक न हो, जबकि अन्य थ्रेड कतार में प्रतीक्षा करें।

सेमाफोर के बिना, उपयोगकर्ता गतिविधि में तेज वृद्धि सर्वर बुनियादी ढाँचे पर अचानक अधिभार का कारण बन सकती है, जिससे टाइमआउट और 429 Too Many Requests त्रुटियाँ हो सकती हैं। Semaphore एक फ़्यूज़ की तरह काम करता है, सक्रिय थ्रेड्स की संख्या की परवाह किए बिना सख्ती से निर्दिष्ट संख्या में समवर्ती कॉल की अनुमति देता है।

Android के लिए Kotlin में Semaphore

Android java.util.concurrent पैकेज से Semaphore क्लास प्रदान करता है। आइए सर्वर अधिभार को रोकने के लिए समवर्ती नेटवर्क अनुरोधों को दो थ्रेड्स तक सीमित करने का उदाहरण देखें।

class ApiClient {
    private val throttle = Semaphore(2)

    suspend fun fetch(url: String): Result {
        throttle.acquire()
        return try {
            httpGet(url)
        } finally {
            throttle.release()
        }
    }
}

iOS के लिए Swift में DispatchSemaphore

iOS में, GCD से DispatchSemaphore उसी कार्य को हल करता है। डेवलपर्स इसका उपयोग मुख्य थ्रेड को ब्लॉक किए बिना अतुल्यकालिक कोड में संसाधनों तक पहुँच को सिंक्रोनाइज़ करने के लिए करते हैं।

let semaphore = DispatchSemaphore(value: 3)

func processBatch(_ items: [UIImage]) {
    for img in items {
        semaphore.wait()
        DispatchQueue.global().async {
            applyFilter(to: img)
            semaphore.signal()
        }
    }
}

सेमाफोर के साथ काम करते समय सामान्य गलतियाँ

सबसे आम गलती अपवाद होने पर भूला हुआ release है। यदि कोई थ्रेड release कॉल करने से पहले त्रुटि के साथ समाप्त होता है, तो सेमाफोर अन्य थ्रेड्स के लिए स्थायी रूप से ब्लॉक रहता है। गारंटीकृत मुक्ति के लिए try/finally या defer का उपयोग करें। दूसरी समस्या विभिन्न थ्रेड्स द्वारा अलग-अलग क्रम में कई सेमाफोर प्राप्त करने पर deadlock है।

सेमाफोर उपयोग पैटर्न

सेमाफोर का उपयोग न केवल डेटा सुरक्षा के लिए, बल्कि जटिल मल्टीथ्रेडेड परिदृश्यों में थ्रेड समन्वय के लिए भी किया जाता है। सामान्य पैटर्न जानने से विकास में तेज़ी आती है और सिंक्रोनाइज़ेशन त्रुटियों की संभावना कम होती है।

वास्तविक प्रोजेक्ट्स में सेमाफोर के उपयोग के कई सिद्ध पैटर्न हैं। उन्हें जानने से सामान्य गलतियों से बचने और विश्वसनीय मल्टीथ्रेडेड सिस्टम बनाने में मदद मिलती है।

दर सीमक (Rate Limiter)

प्रारंभिक मान N और टाइमर के माध्यम से आवधिक release वाला सेमाफोर API अनुरोधों की दर सीमा लागू करता है। उदाहरण के लिए, सेवा प्रति सेकंड 10 अनुरोधों की अनुमति देती है: सेमाफोर 10 से शुरू होता है, प्रत्येक अनुरोध काउंटर घटाता है, और एक अलग TimerTask हर सेकंड काउंटर को उसके प्रारंभिक मान पर लौटाता है। यह एप्लिकेशन और सर्वर दोनों को अधिभार से बचाता है।

सेमाफोर के साथ उत्पादक-उपभोक्ता

क्लासिक उत्पादक-उपभोक्ता समस्या में, दो सेमाफोर एक बफ़र का प्रबंधन करते हैं: empty (लेखन अनुमति) और full (पढ़ने की अनुमति)। उत्पादक empty पर acquire और full पर release कॉल करता है, जबकि उपभोक्ता इसके विपरीत करता है। यह योजना सुनिश्चित करती है कि उपभोक्ता कभी खाली बफ़र न पढ़े और उत्पादक कभी इसे ओवरफ़्लो न करे।

यही योजना ऑपरेटिंग सिस्टम में बाउंडेड बफ़र — निश्चित आकार के रिंग बफ़र का आधार है। मोबाइल एप्लिकेशन में, पैटर्न का उपयोग छवियों, वीडियो फ़ाइलों और विश्लेषणात्मक घटनाओं की कतारों को संसाधित करने के लिए किया जाता है।

नेटवर्क अनुरोधों को थ्रॉटल करना

सेमाफोर का उपयोग पृष्ठभूमि सेवाओं में नेटवर्क कॉल को थ्रॉटल करने के लिए सफलतापूर्वक किया जाता है। उदाहरण के लिए, एक विश्लेषण एप्लिकेशन सर्वर को ईवेंट पैकेट भेजता है। पीक लोड (ऐप लॉन्च, ऑफलाइन के बाद सिंक्रोनाइज़ेशन) के दौरान समवर्ती थ्रेड्स को सीमित किए बिना, एक साथ अनुरोधों की संख्या सर्वर सीमा से अधिक हो सकती है। प्रारंभिक मान 3 वाला सेमाफोर सुचारू भेजना सुनिश्चित करता है और सर्वर-साइड ब्लॉकिंग को रोकता है।