Swift में समवर्तीता और मल्टीथ्रेडिंग: एक संपूर्ण गाइड

Swift में समवर्तीता और मल्टीथ्रेडिंग का परिचय

आधुनिक iOS और macOS एप्लिकेशन तेजी से एक साथ कई कार्यों को निष्पादित करने की मांग करते हैं। चाहे वह नेटवर्क से डेटा लोड करना हो, इमेज प्रोसेसिंग करना हो या जटिल गणितीय गणनाएँ हों — थ्रेड्स के कुशल प्रबंधन के बिना काम नहीं चल सकता। Swift में, समवर्तीता और मल्टीथ्रेडिंग को उच्चतम स्तर पर लागू किया गया है, जो डेवलपर को शक्तिशाली और सुरक्षित उपकरण प्रदान करता है।

इस लेख में, हम तीन मुख्य दृष्टिकोणों पर चर्चा करेंगे: Grand Central Dispatch (GCD), OperationQueue और Swift 5.5 में आया आधुनिक कीवर्ड async/await। आप सीखेंगे कि इनके बीच सही तरीके से कैसे चुनें और रेस कंडीशन (race condition) और डेडलॉक (deadlock) जैसी सामान्य गलतियों से कैसे बचें।

Grand Central Dispatch (GCD) — Swift में मल्टीथ्रेडिंग का क्लासिक तरीका

Grand Central Dispatch (GCD) एक निम्न-स्तरीय Apple लाइब्रेरी है जो थ्रेड पूल का प्रबंधन करती है। डेवलपर को मैन्युअल रूप से थ्रेड बनाने और नष्ट करने की आवश्यकता नहीं है — GCD यह स्वचालित रूप से करता है, कार्यों को प्रोसेसर के उपलब्ध कोर में वितरित करता है।

GCD की मुख्य कतारें

GCD में दो प्रकार की कतारें होती हैं: सीरियल (serial) और कंकरेंट (concurrent)। सीरियल कतार में कार्य एक के बाद एक निष्पादित होते हैं, जबकि कंकरेंट कतार में वे एक साथ शुरू हो सकते हैं।

// सीरियल कतार बनाना
let serialQueue = DispatchQueue(label: "com.example.serial")
serialQueue.async {
    print("कार्य 1")
}
serialQueue.async {
    print("कार्य 2")
}

// कंकरेंट कतार बनाना
let concurrentQueue = DispatchQueue(label: "com.example.concurrent", attributes: .concurrent)
concurrentQueue.async {
    print("कंकरेंट कार्य A")
}
concurrentQueue.async {
    print("कंकरेंट कार्य B")
}

ग्लोबल कतारें और QoS

GCD विभिन्न प्राथमिकताओं (Quality of Service) के साथ तैयार ग्लोबल कतारें प्रदान करता है। जब आपको अपनी खुद की कतार बनाने की आवश्यकता न हो तो इनका उपयोग करें:

• .userInteractive — UI अपडेट के लिए (उच्चतम प्राथमिकता)
• .userInitiated — उपयोगकर्ता द्वारा शुरू किए गए कार्यों के लिए
• .utility — लंबी बैकग्राउंड प्रक्रियाओं के लिए
• .background — उन कार्यों के लिए जो समय के प्रति संवेदनशील नहीं हैं

DispatchQueue.global(qos: .userInitiated).async {
    // भारी काम
    let result = performComplexCalculation()
    DispatchQueue.main.async {
        // UI अपडेट करने के लिए मुख्य थ्रेड पर वापस आएं
        self.updateUI(with: result)
    }
}

महत्वपूर्ण: UI को हमेशा केवल मुख्य थ्रेड (DispatchQueue.main) पर अपडेट करें। इस नियम की अनदेखी करने से एप्लिकेशन में अप्रत्याशित क्रैश हो सकते हैं।

OperationQueue — कार्य निर्भरताओं का प्रबंधन

अगर GCD एक "स्विस आर्मी नाइफ" है, तो OperationQueue एक पूर्ण शेड्यूलर है जिसमें संचालन को रद्द करने, प्राथमिकता देने और उनके बीच निर्भरताएं बनाने की क्षमता है। प्रत्येक संचालन Operation क्लास (या इसके उपवर्ग BlockOperation) का एक इंस्टेंस है।

संचालन बनाना और निष्पादित करना

let operationQueue = OperationQueue()
operationQueue.maxConcurrentOperationCount = 2 // समवर्ती संचालन की संख्या सीमित करें

let operation1 = BlockOperation {
    print("संचालन 1")
}
let operation2 = BlockOperation {
    print("संचालन 2")
}

// निर्भरता जोड़ें: operation2, operation1 के पूरा होने के बाद ही शुरू होगा
operation2.addDependency(operation1)

operationQueue.addOperations([operation1, operation2], waitUntilFinished: false)

रद्द करना और प्राथमिकताएं

GCD के विपरीत, OperationQueue आपको किसी विशिष्ट संचालन या पूरी कतार को रद्द करने की अनुमति देता है:

// एक संचालन रद्द करना
operation1.cancel()

// पूरी कतार रद्द करना
operationQueue.cancelAllOperations()

// प्राथमिकता सेट करना
operation1.
```