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

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

iOS और macOS के लिए आधुनिक एप्लिकेशन तेज़ और उत्तरदायी होने चाहिए। उपयोगकर्ता को इमेज लोड होने या जटिल गणना पूरी होने तक इंतजार नहीं करना चाहिए। इसके लिए Swift में समवर्तीता और मल्टीथ्रेडिंग के तंत्र मौजूद हैं। इस लेख में हम क्लासिक Grand Central Dispatch (GCD) से लेकर Swift Concurrency के आधुनिक async/await तक, मुख्य अवधारणाओं को समझेंगे।

समवर्तीता (concurrency) एक प्रोग्राम की एक साथ कई कार्यों को निष्पादित करने की क्षमता है, उनके बीच स्विच करते हुए। मल्टीथ्रेडिंग (multithreading) समवर्तीता का एक कार्यान्वयन है, जहाँ कार्य ऑपरेटिंग सिस्टम के विभिन्न थ्रेड्स पर निष्पादित होते हैं। Swift इन अवधारणाओं के साथ काम करने के लिए शक्तिशाली और सुरक्षित उपकरण प्रदान करता है।

1. Grand Central Dispatch (GCD) — मल्टीथ्रेडिंग का आधार

Grand Central Dispatch (GCD) कोड के समानांतर निष्पादन को प्रबंधित करने के लिए Apple की एक निम्न-स्तरीय लाइब्रेरी है। यह कतारों (dispatch queues) के आधार पर काम करती है।

GCD में कतारों के प्रकार

• Serial Queue (अनुक्रमिक कतार) — कार्य जोड़े जाने के क्रम में एक के बाद एक निष्पादित होते हैं।
• Concurrent Queue (समानांतर कतार) — कार्य विभिन्न थ्रेड्स पर एक साथ निष्पादित हो सकते हैं।
• Main Queue (मुख्य कतार) — मुख्य थ्रेड पर कार्य निष्पादित करती है, UI अपडेट के लिए अभिप्रेत है।
• Global Queues (वैश्विक कतारें) — विभिन्न प्राथमिकताओं (QoS) वाली सिस्टम समानांतर कतारें।

उदाहरण: बैकग्राउंड में कार्य निष्पादित करना और UI अपडेट करना

import UIKit

class ViewController: UIViewController {    @IBOutlet weak var imageView: UIImageView!

    func loadImage(from url: URL) {        // बैकग्राउंड कतार पर स्विच करें        DispatchQueue.global(qos: .background).async { [weak self] in            guard let data = try? Data(contentsOf: url),                  let image = UIImage(data: data) else {                return            }                        // UI अपडेट करने के लिए मुख्य थ्रेड पर वापस आएं            DispatchQueue.main.async {                self?.imageView.image = image            }        }    }}

इस उदाहरण में, हम इंटरफ़ेस को ब्लॉक न करने के लिए बैकग्राउंड थ्रेड पर इमेज डाउनलोड करते हैं, फिर मुख्य थ्रेड पर UI अपडेट करते हैं।

कार्यों के सिंक्रनाइज़ेशन के लिए DispatchGroup

DispatchGroup आपको एसिंक्रोनस कार्यों के एक समूह के निष्पादन को ट्रैक करने और उनके पूरा होने के बाद एक कार्रवाई करने की अनुमति देता है।

let group = DispatchGroup()

group.enter()fetchData1 { result in    print("डेटा 1 प्राप्त हुआ")    group.leave()}

group.enter()fetchData2 { result in    print("डेटा 2 प्राप्त हुआ")    group.leave()}

group.notify(queue: .main) {    print("सभी डेटा लोड हो गए, UI अपडेट कर रहे हैं")}

2. OperationQueue — ऑब्जेक्ट-ओरिएंटेड दृष्टिकोण

OperationQueue, GCD के ऊपर एक उच्च-स्तरीय एब्स्ट्रैक्शन है। यह Operation ऑब्जेक्ट्स के साथ काम करता है, जो कार्य की एक इकाई का प्रतिनिधित्व करते हैं।

OperationQueue के लाभ

• कार्यों को रद्द करने की क्षमता (cancel)।
• संचालन के बीच निर्भरताएँ सेट करना (addDependency)।
• संचालन की स्थिति की निगरानी (isFinished, isExecuting, isCancelled)।
• समानांतर संचालन की अधिकतम संख्या का कॉन्फ़िगरेशन।

उदाहरण: कई इमेज लोड करना

import UIKit

class ImageLoader {    private let queue = OperationQueue()        func loadImages(from urls: [URL], completion: @escaping ([UIImage]) -> Void) {        var images: [UIImage] = []        let completionOperation = BlockOperation {            DispatchQueue.main.async {                completion(images)            }        }                for url in urls {            let o