DispatchQueue: यह क्या है, GCD कतार और मल्टीथ्रेडिंग के मूल सिद्धांत

DispatchQueue और Grand Central Dispatch क्या है

DispatchQueue Grand Central Dispatch (GCD) फ्रेमवर्क की एक वस्तु है जो सिस्टम या कस्टम थ्रेड कतारों में कार्य निष्पादन का प्रबंधन करती है। Grand Central Dispatch एक निम्न-स्तरीय Apple लाइब्रेरी है, जो iOS 4 और macOS 10.6 से उपलब्ध है, जो डेवलपर से थ्रेड प्रबंधन को पूरी तरह से अमूर्त करती है। GCD ऑपरेटिंग सिस्टम थ्रेड पूल का उपयोग करता है और डिवाइस लोड के अनुसार स्वचालित रूप से थ्रेड्स की संख्या को स्केल करता है।

डेवलपर को मैन्युअल रूप से थ्रेड बनाने और नष्ट करने की आवश्यकता नहीं है — GCD यह कार्य संभालता है, DispatchQueue के माध्यम से एक सरल API प्रदान करता है। क्लोज़र के रूप में एक कार्य sync या async विधियों के माध्यम से कतार में भेजा जाता है। पहले मामले में, कॉल करने वाला थ्रेड कार्य पूरा होने तक ब्लॉक हो जाता है; दूसरे में, निष्पादन तुरंत जारी रहता है।

Apple (2026) के अनुसार, GCD एक सिस्टम थ्रेड पूल का उपयोग करता है जो कोर की संख्या और वर्तमान CPU लोड के अनुसार अनुकूलित होता है। कंकरंट कतार प्रत्येक कार्य के लिए एक नया थ्रेड नहीं बनाती है — GCD पूल से थ्रेड का पुन: उपयोग करता है, थ्रेड निर्माण के ओवरहेड को कम करता है।

GCD आर्किटेक्चर

Grand Central Dispatch तीन प्रमुख घटकों से बना है: कतारें (DispatchQueue), समूह (DispatchGroup), और सेमाफोर (DispatchSemaphore)। कतार प्राथमिक तत्व है जो कोड ब्लॉक के रूप में कार्य स्वीकार करती है। DispatchGroup एकाधिक कार्यों के निष्पादन को सिंक्रोनाइज़ करता है, जबकि DispatchSemaphore एक साझा संसाधन तक पहुँच को थ्रेड्स की एक विशिष्ट संख्या तक सीमित करता है।

प्रत्येक GCD कतार एक विशिष्ट QoS (Quality of Service) वर्ग से जुड़ी होती है, जो सिस्टम को कार्य के महत्व के बारे में सूचित करती है। सिस्टम कतारों के बीच CPU समय वितरित करने के लिए QoS का उपयोग करता है, अधिक महत्वपूर्ण कार्यों को प्राथमिकता देता है — जैसे UI अपडेट या उपयोगकर्ता स्पर्श हैंडलिंग।

सीरियल और कंकरंट कतारें: तुलना

सीरियल कतार कार्यों को सख्ती से क्रमिक रूप से निष्पादित करती है, एक के बाद एक। यदि सीरियल कतार में तीन कार्य रखे जाते हैं, तो दूसरा कार्य पहले के पूरी तरह से पूरा होने के बाद ही शुरू होता है। सीरियल कतारों का उपयोग साझा संसाधनों तक पहुँच को सिंक्रोनाइज़ करने के लिए किया जाता है — उदाहरण के लिए, एक ऐरे जिसे कोड के कई भागों से संशोधित किया जाता है।

कंकरंट कतार एक साथ कई कार्य चलाती है, उन्हें सिस्टम पूल से उपलब्ध थ्रेड्स पर वितरित करती है। कंकरंट कतार पर कार्य FIFO क्रम में शुरू होते हैं, लेकिन यदि उनका निष्पादन समय भिन्न होता है तो यादृच्छिक क्रम में पूरे होते हैं। कंकरंट कतार पूरा होने के क्रम की गारंटी नहीं देती — केवल शुरू होने के क्रम की।

सीरियल कतार कब चुनें

सीरियल कतार उन कार्यों के लिए आदर्श है जो साझा स्थिति को संशोधित करते हैं — फ़ाइल में लिखना, डेटा मॉडल अपडेट करना, या Core Data के साथ काम करना। सीरियल कतार का उपयोग गारंटी देता है कि कोड के दो भाग एक साथ समान डेटा को संशोधित नहीं करेंगे, अतिरिक्त लॉक के बिना रेस कंडीशन को समाप्त करता है।

कंकरंट कतार कब चुनें

कंकरंट कतार उन कार्यों के लिए उपयुक्त है जो एक-दूसरे पर निर्भर नहीं हैं: एकाधिक छवियाँ लोड करना, समानांतर नेटवर्क अनुरोध, या डेटा का बैच प्रोसेसिंग। GCD स्वचालित रूप से तय करता है कि CPU कोर की संख्या और वर्तमान सिस्टम लोड के आधार पर एक साथ कितने कार्य चलाने हैं।

Quality of Service: कार्य निष्पादन प्राथमिकताएँ

QoS (Quality of Service) एक GCD तंत्र है जो ऑपरेटिंग सिस्टम को कार्य के महत्व और तात्कालिकता के बारे में सूचित करता है। सिस्टम थ्रेड शेड्यूलिंग के लिए QoS का उपयोग करता है: उच्च QoS वाले कार्यों को अधिक CPU समय मिलता है और वे पहले शुरू होते हैं। QoS मान कतार बनाते समय या विशिष्ट कार्य सबमिट करते समय पारित किया जाता है।

GCD में पाँच QoS वर्ग उपलब्ध हैं। .userInteractive — UI-संबंधित कार्यों के लिए उच्चतम प्राथमिकता। .userInitiated — उपयोगकर्ता द्वारा शुरू किए गए कार्यों के लिए। .utility — पृष्ठभूमि कार्यों के लिए जो प्रगति दिखाते हैं। .background — उपयोगकर्ता के लिए अदृश्य कार्यों के लिए। .default — userInitiated और utility के बीच एक मध्यवर्ती स्तर, डिफ़ॉल्ट रूप से उपयोग किया जाता है।

Apple (2026) के अनुसार, गलत QoS चयन प्रदर्शन समस्याओं के सामान्य कारणों में से एक है। QoS .userInteractive के साथ पृष्ठभूमि डाउनलोड चलाना UI से संसाधन लेता है, जिससे एनिमेशन में माइक्रो-लैग होता है। अनुशंसा की जाती है कि सबसे कम QoS चुनें जो अभी भी स्वीकार्य निष्पादन समय प्रदान करता हो।

QoS उपयोग उदाहरण

तत्काल प्रदर्शन के लिए छवि लोड करते समय, .userInitiated का उपयोग करें — उपयोगकर्ता परिणाम की अपेक्षा करता है। अगली स्क्रीन को प्रीलोड करने के लिए, .utility पर्याप्त है। पृष्ठभूमि सर्वर सिंक्रोनाइज़ेशन .background के साथ चलता है, सक्रिय कार्यों पर प्रभाव को कम करता है।

DispatchGroup और सेमाफोर: कार्य सिंक्रोनाइज़ेशन

DispatchGroup कार्यों के एक समूह के पूरा होने को ट्रैक करने की अनुमति देता है। जब समूह के सभी कार्य पूरे हो जाते हैं, GCD निर्दिष्ट कतार पर notify हैंडलर को कॉल करता है। यह विशेष रूप से तब उपयोगी होता है जब कई स्वतंत्र संसाधन लोड किए जाते हैं — प्रोफ़ाइल डेटा, मित्र सूची, और सेटिंग्स — जहाँ इंटरफ़ेस को सभी डेटा प्राप्त होने के बाद ही अपडेट करना चाहिए।

DispatchGroup एक सिंक्रोनस wait() कॉल का समर्थन करता है, जो सभी कार्यों के पूरा होने तक वर्तमान थ्रेड को ब्लॉक करता है। यह तब सुविधाजनक होता है जब कोड समूह के परिणामों के बिना जारी नहीं रह सकता। एसिंक्रोनस वेरिएंट notify() सभी कार्यों के पूरा होने के बाद निर्दिष्ट कतार पर क्लोज़र को कॉल करता है, कॉल करने वाले थ्रेड को ब्लॉक किए बिना।

समांतरता सीमित करने के लिए DispatchSemaphore

DispatchSemaphore एक संसाधन तक पहुँच को नियंत्रित करता है, एक साथ पहुँच की संख्या को सीमित करता है। प्रारंभिक मान 3 वाला सेमाफोर तीन से अधिक समानांतर कार्यों की अनुमति नहीं देता है। wait() कॉल करने पर काउंटर घटता है, signal() पर बढ़ता है। यदि काउंटर शून्य हो जाता है, तो संसाधन उपलब्ध होने तक थ्रेड ब्लॉक हो जाता है।

Swift में DispatchQueue के साथ कोड उदाहरण

Swift में DispatchQueue का उपयोग करने के तीन व्यावहारिक उदाहरण देखें। पहला मुख्य थ्रेड पर वापसी के साथ एक बुनियादी async कॉल प्रदर्शित करता है, दूसरा सीरियल कतार के माध्यम से सिंक्रोनाइज़ेशन दिखाता है, और तीसरा समानांतर अनुरोधों के लिए DispatchGroup का उपयोग करता है।

मुख्य पर वापसी के साथ बुनियादी async कॉल

DispatchQueue.main मुख्य थ्रेड की सीरियल कतार है, जो विशेष रूप से UI संचालन के लिए है। पृष्ठभूमि कार्य पूरा करने के बाद इंटरफ़ेस अपडेट करने के लिए हमेशा इसका उपयोग करें।

let queue = DispatchQueue.global(qos: .userInitiated)
queue.async {
    let data = self.fetchData()
    DispatchQueue.main.async {
        self.updateUI(with: data)
    }
}

साझा संसाधन की सुरक्षा के लिए सीरियल कतार

एक अद्वितीय पहचानकर्ता के साथ कस्टम सीरियल कतार बनाना परिवर्तनीय ऐरे तक पहुँच को सिंक्रोनाइज़ करता है। सभी पढ़ने और लिखने के संचालन एक ही कतार से गुज़रते हैं, रेस कंडीशन को समाप्त करते हैं।

let serialQueue = DispatchQueue(label: "com.app.items")
var items: [Int] = []

serialQueue.async {
    items.append(1)
}
serialQueue.async {
    let last = items.last
    DispatchQueue.main.async {
        print("Last item: \(last)")
    }
}

समानांतर अनुरोधों के लिए DispatchGroup

DispatchGroup कंकरंट कतार पर एकाधिक कार्य शुरू करने और सभी के पूरा होने पर सूचना प्राप्त करने की अनुमति देता है। यह प्रोफ़ाइल स्क्रीन के लिए डेटा लोड करते समय उपयोगी है।

let group = DispatchGroup()
let worker = DispatchQueue.global()

worker.async(group: group) { self.loadProfile() }
worker.async(group: group) { self.loadFriends() }
worker.async(group: group) { self.loadSettings() }

group.notify(queue: DispatchQueue.main) {
    self.showCompleteUI()
}

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

डेडलॉक जब सीरियल कतार पर sync कॉल किया जाता है — सबसे आम गलती है। यदि सीरियल कतार पर कोई कार्य उसी कतार पर queue.sync कॉल करता है, तो थ्रेड हमेशा के लिए ब्लॉक हो जाता है। कतार वर्तमान कार्य के पूरा होने की प्रतीक्षा करती है, और कार्य sync कॉल के पूरा होने की प्रतीक्षा करता है — एक क्लासिक आपसी ब्लॉकिंग।

पृष्ठभूमि थ्रेड से UI अपडेट करना

UIKit के साथ सभी संचालन मुख्य थ्रेड पर किए जाने चाहिए। Xcode Main Thread Checker के माध्यम से डीबग मोड में ऐसी त्रुटियों का पता लगाता है। Release बिल्ड में, वे अप्रत्याशित व्यवहार का कारण बनती हैं: एनिमेशन शुरू नहीं होते, UI अपडेट नहीं होता, क्रैश हो सकते हैं।

कस्टम कतारों का अत्यधिक निर्माण

वैश्विक कतारों के बजाय सैकड़ों कस्टम कतारें बनाना एक एंटीपैटर्न है। प्रत्येक कतार सिस्टम संसाधनों का उपभोग करती है। अधिकांश कार्यों के लिए, विभिन्न QoS स्तरों के साथ वैश्विक कंकरंट कतारें और साझा डेटा को सिंक्रोनाइज़ करने के लिए एक या दो सीरियल कतारें पर्याप्त हैं।

लूप में autoreleasepool को अनदेखा करना

autoreleasepool के बिना पृष्ठभूमि कतार पर संसाधन-गहन लूप कार्य निष्पादित करते समय, मेमोरी पूरे लूप के समाप्त होने तक बढ़ती है। ARC केवल autorelease पूल से बाहर निकलने पर ऑब्जेक्ट जारी करता है। समय पर मेमोरी डीलोकेशन के लिए लूप पुनरावृत्तियों को autoreleasepool { } में लपेटें।