Dispatch के बाद Swift: उदाहरणों के साथ GCD 3, 4 और 5 के लिए

Swift 3, 4 और 5 में विलंब से कैसे डरना छोड़ें और GCD से प्यार करें

क्या आपने कभी ऐसा कोड लिखा है जो तीन सेकंड के बाद निष्पादित होना चाहिए था, लेकिन तुरंत काम कर गया? या, इसके विपरीत, आपने पूरी एक सदी इंतजार किया, जबकि आपने कुछ मिलीसेकंड की योजना बनाई थी? परिचित लगता है? तो आप निश्चित रूप से dispatch_after से परिचित हुए हैं - जो Grand Central Dispatch (GCD) के सबसे लोकप्रिय, लेकिन सबसे कपटी उपकरणों में से एक है।

पहले, Swift 2 और Objective-C के युग में, यह विधि एक मंत्र की तरह दिखती थी: dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(nanoseconds)), dispatch_get_main_queue())। लेकिन Swift 3, 4 और 5 के आगमन के साथ, GCD API को पूरी तरह से फिर से लिखा गया। अब यह सिर्फ नाम बदलना नहीं है - यह सोचने का एक नया तरीका है। इस लेख में, हम सभी वर्तमान संस्करणों पर Swift में dispatch_after लिखने का तरीका समझेंगे, मिथकों को दूर करेंगे और तैयार समाधान देंगे। चलिए शुरू करते हैं!

dispatch_after का क्या हुआ? दर्द का एक संक्षिप्त इतिहास

Swift 3 से पहले, डेवलपर्स C-शैली GCD का उपयोग करते थे:

let delay = dispatch_time(DISPATCH_TIME_NOW, Int64(2.0 * Double(NSEC_PER_SEC)))\ndispatch_after(delay, dispatch_get_main_queue()) {\n    print("अतीत से नमस्ते!")\n}

यह काम करता था, लेकिन बोझिल लगता था। Swift 3 में, Apple ने GCD को "स्विफ्टीफाई" करने का फैसला किया, इसे एक ऑब्जेक्ट-ओरिएंटेड API में बदल दिया। अब dispatch_after DispatchQueue संरचना की एक विधि asyncAfter में बदल गया है। और यह सिर्फ एक कॉस्मेटिक मरम्मत नहीं है - यह पूरी तरह से नया सिंटैक्स है जिसके लिए समझ की आवश्यकता है।

मुख्य नुस्खा: Swift 3, 4 और 5 में asyncAfter

Swift के संस्करण (3, 4 या 5) के बावजूद, dispatch_after का मूल सिंटैक्स अब समान दिखता है। मुख्य थ्रेड पर विलंबित निष्पादन का सबसे सरल उदाहरण यहां दिया गया है:

let delayInSeconds: Double = 2.0\nDispatchQueue.main.asyncAfter(deadline: .now() + delayInSeconds) {\n    print("2 सेकंड बीत गए!")\n}

मुख्य बिंदु:

\n
• DispatchQueue.main — मुख्य थ्रेड (UI)।
\n
• .now() + delayInSeconds — वर्तमान क्षण के सापेक्ष एक deadline (अंतिम समय सीमा) बनाएं।
\n
• asyncAfter — निर्दिष्ट समय के बाद अतुल्यकालिक निष्पादन।
\n

यह कोड Swift 3.0, 4.0 और 5.0 में बिना किसी बदलाव के काम करता है। जादू यह है कि Apple ने 2016 के बाद इस API को स्थिर रखा।

dispatch_time के बारे में क्या? नैनोसेकंड के साथ काम करना

कभी-कभी आपको नैनोसेकंड में विलंब निर्दिष्ट करने की आवश्यकता होती है (उदाहरण के लिए, सटीक टाइमर या गेम लॉजिक के लिए)। नए API में DispatchTime का उपयोग किया जाता है:

let nanoseconds: Int = 1_500_000_000 // 1.5 सेकंड\nlet deadline = DispatchTime.now() + .nanoseconds(nanoseconds)\nDispatchQueue.global().asyncAfter(deadline: deadline) {\n    print("बैकग्राउंड थ्रेड में 1.5 सेकंड के बाद निष्पादित")\n}

आप तैयार स्थिरांक का भी उपयोग कर सकते हैं: .seconds(5), .milliseconds(500) और यहां तक कि .microseconds(1000)। यह NSEC_PER_SEC से गुणा करने से अधिक सुविधाजनक है।

Swift में dispatch_after के बारे में बार-बार पूछे जाने वाले प्रश्न (और उत्तर!)

Stack Overflow पर इस प्रश्न ने हजारों बार देखा गया है। यहां सबसे आम गलतियाँ हैं जो शुरुआती करते हैं।

1. मेरा कोड विलंब के बजाय तुरंत क्यों निष्पादित होता है?

सबसे आम गलती asyncAfter और async के बीच भ्रम है। यदि आप deadline: निर्दिष्ट करना भूल गए या DispatchQueue.main.async { ... } लिखा, तो कोड तुरंत निष्पादित होगा। दूसरा कारण: ऋणात्मक मान पास करना। .now() + (-5.0) — यह बीता हुआ समय है, GCD ब्लॉक को तुरंत निष्पादित करेगा।

2. dispatch_after को कैसे रद्द करें?

Timer के विपरीत, asyncAfter में कोई अंतर्निहित cancel() विधि नहीं है। लेकिन दो समाधान हैं:

\n
• रद्दीकरण फ़्लैग: Dispatc का उपयोग करें