OperationQueue — यह क्या है, Operation और कार्य प्रबंधन

OperationQueue और Operation क्या है

OperationQueue Foundation फ्रेमवर्क का एक वर्ग है जो Operation ऑब्जेक्ट्स के निष्पादन का प्रबंधन करता है। DispatchQueue के विपरीत, OperationQueue को सीरियल या कंकरेंट मोड स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता नहीं है — एक साथ निष्पादित होने वाले संचालनों की संख्या maxConcurrentOperationCount प्रॉपर्टी द्वारा नियंत्रित की जाती है। मान 1 कतार को अनुक्रमिक बनाता है, कोई अन्य मान इसे समवर्ती बनाता है।

Operation एक अमूर्त वर्ग है जो कार्य की एक इकाई का प्रतिनिधित्व करता है। प्रत्येक संचालन की एक अवस्था होती है: ready, executing, finished या cancelled। ये अवस्थाएं KVO (Key-Value Observing) के साथ संगत हैं, जो परिवर्तनों पर प्रतिक्रिया करने की अनुमति देती हैं — उदाहरण के लिए, संचालन पूरा होने पर UI अपडेट करना। Operation स्वचालित रूप से isExecuting और isFinished फ्लैग प्रबंधित करता है।

Apple (2026) के अनुसार, OperationQueue आंतरिक रूप से GCD का उपयोग करती है लेकिन DispatchQueue में उपलब्ध नहीं होने वाली कार्यक्षमता जोड़ती है: संचालनों की निर्भरताएं, प्राथमिकताएं और रद्दीकरण। यदि ऐप बैकग्राउंड में जाता है, तो OperationQueue निष्पादन को रोक देती है और वापस आने पर फिर से शुरू कर देती है। OperationQueue स्वचालित रूप से CPU कोर की संख्या पर भी विचार करती है और थ्रेड्स की इष्टतम संख्या चुनती है।

Operation का जीवनचक्र

प्रत्येक संचालन चार अवस्थाओं से गुज़रता है: pending (लंबित), ready (तैयार), executing (निष्पादित हो रहा) और finished (पूर्ण)। cancelled अवस्था पूर्ण होने से पहले किसी भी चरण में हो सकती है। अवस्था परिवर्तन KVO के माध्यम से ट्रैक किए जाते हैं — यह प्रतिक्रियाशील UI अपडेट का आधार है। OperationQueue स्वचालित रूप से पूर्ण संचालनों को कतार से हटाती है और निर्भर संचालनों को सूचित करती है कि उनकी पूर्वापेक्षा पूरी हो गई है, जिससे उनका निष्पादन शुरू होता है।

Operation और BlockOperation: कार्यों का कार्यान्वयन

Operation एक अमूर्त वर्ग है जिसमें main() या start() विधि को ओवरराइड करने की आवश्यकता होती है। कार्य कोड main() विधि में रखा जाता है, और isExecuting और isFinished अवस्थाएं स्वचालित रूप से प्रबंधित होती हैं। एसिंक्रोनस संचालनों के लिए, start() को ओवरराइड करना और अवस्था फ्लैग को मैन्युअल रूप से प्रबंधित करना आवश्यक है।

BlockOperation Operation का एक ठोस कार्यान्वयन है जो कोड के एक या अधिक ब्लॉक निष्पादित करता है। यदि आप addExecutionBlock() के माध्यम से कई ब्लॉक जोड़ते हैं तो BlockOperation समवर्ती हो जाता है। संचालन केवल सभी जोड़े गए ब्लॉक के निष्पादित होने के बाद पूरा होता है। BlockOperation बिना इनहेरिटेंस के सरल कार्यों के लिए एक सुविधाजनक विकल्प है।

कस्टम Operation बनाना

कस्टम संचालन बनाने के लिए, Operation से सबक्लास बनाएं और main() को ओवरराइड करें। अंदर, महंगे संचालनों से पहले isCancelled फ्लैग की जांच करें ताकि तेजी से रद्दीकरण सुनिश्चित हो सके। यह बड़ी फ़ाइलें डाउनलोड करने या बैच डेटा प्रोसेसिंग के लिए महत्वपूर्ण है। Operation और BlockOperation के बीच चयन कार्य की जटिलता पर निर्भर करता है: सरल एक बार की कार्रवाइयों के लिए BlockOperation पर्याप्त है; अवस्था के साथ पुन: प्रयोज्य तर्क के लिए, Operation से सबक्लास करें।

संचालनों की निर्भरताएं और प्राथमिकताएं

निर्भरताएं DispatchQueue पर OperationQueue का मुख्य लाभ हैं। विधि addDependency(_:) निर्दिष्ट करती है कि संचालन B केवल संचालन A के पूरा होने के बाद ही निष्पादित होता है। निर्भरताएं एक निर्देशित अचक्रीय ग्राफ (DAG) बनाती हैं: यदि एक चक्रीय निर्भरता जोड़ी जाती है, तो कतार इसे अनदेखा करती है और संचालन शुरू नहीं होते हैं।

प्राथमिकता संचालन की queuePriority प्रॉपर्टी के माध्यम से मानों के साथ सेट की जाती है: .veryLow, .low, .normal, .high, .veryHigh। प्राथमिकता तैयार संचालनों के बीच प्रारंभ क्रम को प्रभावित करती है लेकिन निर्भरताओं को ओवरराइड नहीं करती। OperationQueue पहले निर्भरताओं को हल करती है, फिर उपलब्ध संचालनों के बीच प्राथमिकता लागू करती है।

निर्भरताओं का व्यावहारिक उदाहरण

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

समवर्तीता को सीमित करना

maxConcurrentOperationCount प्रॉपर्टी एक साथ निष्पादित होने वाले संचालनों की संख्या को सीमित करती है। मान 1 एक अनुक्रमिक कतार बनाता है, डिफ़ॉल्ट मान (NSOperationQueueDefaultMaxConcurrentOperationCount) सिस्टम-इष्टतम है, जो वर्तमान डिवाइस लोड पर निर्भर करता है। इस पैरामीटर का उचित कॉन्फ़िगरेशन अत्यधिक संसाधन खपत को रोकता है: छवि लोड करने के लिए, 4–6 समवर्ती संचालन पर्याप्त हैं; CPU-गहन कार्यों के लिए, प्रोसेसर कोर की संख्या का उपयोग करें।

OperationQueue vs DispatchQueue: तुलना

OperationQueue और DispatchQueue के बीच चयन कार्य जटिलता पर निर्भर करता है। DispatchQueue सरल async कॉल के लिए एक हल्का उपकरण है। OperationQueue कई परस्पर संबंधित कार्यों वाले जटिल परिदृश्यों के लिए एक भारी समाधान है। Apple DispatchQueue से शुरू करने और केवल निर्भरताओं या रद्दीकरण की आवश्यकता होने पर OperationQueue पर स्विच करने की सलाह देता है। अधिकांश iOS परियोजनाओं के लिए, दोनों उपकरणों का संयोजन प्रदर्शन और लचीलेपन का इष्टतम संतुलन प्रदान करता है।

• DispatchQueue — हल्का, तेज़, Operation ऑब्जेक्ट्स के ओवरहेड के बिना
• OperationQueue — निर्भरताएं, रद्दीकरण, KVO और प्राथमिकताओं का समर्थन करता है
• DispatchQueue — सरल async/asyncAfter कार्यों और सीरियल सिंक्रोनाइज़ेशन के लिए आदर्श
• OperationQueue — अनुक्रमिक चरणों वाले चरण-दर-चरण एल्गोरिदम के लिए अपरिहार्य
• DispatchQueue — Continuation के माध्यम से Swift Concurrency (async/await) के साथ एकीकृत होता है

Ray Wenderlich (2025) के अनुसार, बड़ी iOS परियोजनाओं में, OperationQueue का उपयोग प्रगति और रद्दीकरण के साथ सामग्री लोड करने के लिए किया जाता है, जबकि DispatchQueue का उपयोग अन्य सभी async संचालनों के लिए किया जाता है। अनुपात लगभग 20 से 80 DispatchQueue के पक्ष में है।

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

आइए तीन उदाहरण देखें: एक सरल BlockOperation, निर्भरताओं के साथ एक कस्टम Operation, और डेटा लोड करने के लिए एक रद्द करने योग्य संचालन।

पूर्णता के साथ BlockOperation

सबसे सरल मामला — OperationQueue पर एक ब्लॉक निष्पादित करें और completionBlock के माध्यम से परिणाम संभालें। प्रत्येक Operation में एक अंतर्निहित completionBlock प्रॉपर्टी होती है, जो main() के समाप्त होने के बाद कॉल की जाती है।

let queue = OperationQueue()
let operation = BlockOperation()
operation.addExecutionBlock {
    let data = NetworkService.fetchData()
    OperationQueue.main.addOperation {
        self.updateUI(data)
    }
}
queue.addOperation(operation)

संचालनों के बीच निर्भरताएं

निर्भरता सुनिश्चित करती है कि parseOperation केवल downloadOperation के पूरा होने के बाद ही शुरू हो। यह नेस्टेड कॉलबैक की आवश्यकता को समाप्त करता है।

let download = BlockOperation { self.downloadJSON() }
let parse = BlockOperation { self.parseJSON() }
parse.addDependency(download)

let queue = OperationQueue()
queue.addOperations([download, parse], waitUntilFinished: false)

रद्द करने योग्य कस्टम Operation

आवधिक isCancelled जांच के साथ main() को ओवरराइड करें। यह संचालन को रद्द होने पर तुरंत रुकने की अनुमति देता है, बिना किसी महंगे संचालन के पूरा होने की प्रतीक्षा किए।

class ImageLoadOperation: Operation {
    override func main() {
        guard !self.isCancelled else { return }
        let image = self.downloadImage()
        guard !self.isCancelled else { return }
        OperationQueue.main.addOperation { self.display(image) }
    }
}

संचालन रद्दीकरण और KVO अवलोकन

रद्दीकरण संचालन का isCancelled फ्लैग को true पर सेट करता है, लेकिन पहले से चल रही main() विधि को नहीं रोकता है। main() के अंदर कोड को स्वयं isCancelled की जांच करनी चाहिए और आवश्यकता पड़ने पर समाप्त हो जाना चाहिए। यह Apple का वास्तुशिल्प निर्णय है — जो डेवलपर को रद्दीकरण पर संसाधनों को सही ढंग से मुक्त करने की अनुमति देता है।

KVO अवलोकन isFinished और isExecuting प्रॉपर्टीज का स्पष्ट कॉलबैक के बिना संचालनों के पूरा होने पर प्रतिक्रिया करने की अनुमति देता है। OperationQueue स्वचालित रूप से पूर्ण संचालनों को कतार से हटाती है, लेकिन वे मेमोरी में तब तक रहते हैं जब तक उनके मजबूत संदर्भ मौजूद हैं। KVO RxSwift या Combine जैसे प्रतिक्रियाशील फ्रेमवर्क के साथ OperationQueue को एकीकृत करने का आधार है।

KVO के माध्यम से रद्दीकरण को संभालना

KVO के माध्यम से isCancelled की सदस्यता लेना संचालन रद्दीकरण पर UI अपडेट करने की अनुमति देता है — उदाहरण के लिए, रद्द किए गए डाउनलोड के बजाय प्लेसहोल्डर दिखाना। isCancelled प्रॉपर्टी KVO-संगत है, जो इसे प्रतिक्रियाशील पाइपलाइनों के लिए सुविधाजनक बनाती है।

OperationQueue के साथ काम करने के सर्वोत्तम अभ्यास

बड़ी संख्या में संचालन न बनाएं — प्रत्येक Operation मेमोरी में एक अलग ऑब्जेक्ट है। यदि कोई कार्य छोटा है और निर्भरताओं की आवश्यकता नहीं है, तो सीधे DispatchQueue का उपयोग करें। OperationQueue स्पष्ट निर्भरताओं, रद्दीकरण और प्रगति निगरानी वाले जटिल परिदृश्यों के लिए उचित है।

महंगे संचालनों से पहले isCancelled जांचें main() विधि के अंदर। फ़ाइल डाउनलोड करने या छवि प्रसंस्करण के मामलों में, प्रत्येक महत्वपूर्ण चरण के बाद जांच करना रद्दीकरण के लिए त्वरित प्रतिक्रिया सुनिश्चित करता है। main() की शुरुआत में और प्रत्येक बड़े संचालन के बाद if isCancelled { return } का उपयोग करें।

completionBlock को ठीक से प्रबंधित करें। संचालन का completionBlock प्रॉपर्टी main() के समाप्त होने के बाद कॉल की जाती है, भले ही संचालन रद्द कर दिया गया हो। गलत डेटा के साथ UI अपडेट करने से बचने के लिए completionBlock के अंदर isCancelled जांचें। OperationQueue.main UI संचालनों के लिए एक थ्रेड-सुरक्षित कतार है, जो DispatchQueue.main के समान है।

चक्रीय निर्भरताओं से बचें — वे चक्र में किसी भी संचालन को कभी शुरू नहीं होने देतीं। OperationQueue स्वचालित रूप से चक्र का पता नहीं लगाती: यदि A, B पर निर्भर है और B, A पर निर्भर है, तो दोनों हमेशा ready अवस्था में रहेंगे। पहले से निर्भरता ग्राफ की योजना बनाएं।