स्विफ्ट 6 ने ऐप्स में सहभागिता के लिए एक नया दृष्टिकोण पेश किया। इस लेख में, हम उन समस्याओं का पता लगाने जा रहे हैं जो इसे हल करने का लक्ष्य रखते हैं, समझाते हैं कि यह कैप के तहत कैसे काम करता है, पिछले के साथ नए मॉडल की तुलना करते हैं, और एक्टर मॉडल को करीब से देखते हैं। स्विफ्ट प्रतिस्पर्धा समीक्षा: समस्याएं और समाधान प्रतियोगिता लंबे समय से सॉफ्टवेयर विकास के सबसे चुनौतीपूर्ण पहलुओं में से एक है. कोड लिखना जो कार्यों को एक ही समय में चलाता है, प्रदर्शन और प्रतिक्रियाशीलता में सुधार कर सकता है, लेकिन यह अक्सर जटिलता और रेस स्थितियों, deadlocks और तार-सुरक्षा मुद्दों के रूप में सूक्ष्म बग पेश करता है। Swift Concurrency, Swift 6 में पेश किया गया है, एक स्पष्ट, सुरक्षित और कुशल मॉडल प्रदान करके समकक्ष प्रोग्रामिंग को सरल बनाने का लक्ष्य रखता है, asynchronous कार्यों को संभालने के लिए. यह डेवलपर्स को डेटा पहुंच और निष्पादन क्रम के आसपास सख्त नियमों को लागू करके आम पट्टियों से बचने में मदद करता है. 💡यदि आप स्विफ्ट 5.x का उपयोग करते हैं और स्विफ्ट 6 को स्थानांतरित करने की योजना बनाते हैं, तो आप अपनी परियोजना सेटिंग्स में स्विफ्ट कॉर्कुलेशन चेक को सक्षम कर सकते हैं. यह आपको मौजूदा कोड के साथ संगतता बनाए रखते हुए नए कॉर्कुलेशन मॉडल को धीरे-धीरे अपनाने की अनुमति देता है. इन चेक को सक्षम करने से संभावित कॉर्कुलेशन मुद्दों को जल्दी पकड़ने में मदद मिलती है, जिससे संक्रमण चिकनी और सुरक्षित हो जाता है. जब आप अपने कोडबेस को अपडेट करते हैं, तो आप पूरी तरह से फिर से लिखने के बिना async/await सिंटाक्स और अन्य स्विफ्ट कॉर्कुलेशन सुविधाओं को एकीकृत करना शुरू कर सकते हैं. 💡यदि आप स्विफ्ट 5.x का उपयोग करते हैं और स्विफ्ट 6 को स्थानांतरित करने की योजना बनाते हैं, तो आप अपनी परियोजना सेटिंग्स में स्विफ्ट कॉर्कुलेशन चेक को सक्षम कर सकते हैं. यह आपको मौजूदा कोड के साथ संगतता बनाए रखते हुए नए कॉर्कुलेशन मॉडल को धीरे-धीरे अपनाने की अनुमति देता है. इन चेक को सक्षम करने से संभावित कॉर्कुलेशन मुद्दों को जल्दी पकड़ने में मदद मिलती है, जिससे संक्रमण चिकनी और सुरक्षित हो जाता है. जब आप अपने कोडबेस को अपडेट करते हैं, तो आप पूरी तरह से फिर से लिखने के बिना async/await सिंटाक्स और अन्य स्विफ्ट कॉर्कुलेशन सुविधाओं को एकीकृत करना शुरू कर सकते हैं. Some of the key problems Swift Concurrency addresses include: दौड़ की शर्तें: साझा परिवर्तनीय राज्य तक एक साथ पहुंच को रोकना जो अप्रत्याशित व्यवहार का कारण बन सकता है। कॉलबैक नरक: एसिंक्रोनिक कोड को सरल बनाने के लिए जो पहले भारी रूप से निहित कॉलबैक या पूरा करने वाले प्रबंधकों पर भरोसा करते थे, कोड को पढ़ने और बनाए रखने में आसान बनाते हैं। थ्रेड प्रबंधन जटिलता: कम-स्तरीय निर्माण और सिंक्रनाइज़ेशन को दूर करने के लिए, डेवलपर्स को थ्रेड प्रबंधन के बजाय तर्क पर ध्यान केंद्रित करने की अनुमति देता है। समकक्ष कार्यों को समन्वित करना: संरचित समकक्षता उचित रद्द और त्रुटियों के प्रसार के साथ कार्यों की स्पष्ट रीढ़ की अनुमति देता है। नई भाषाओं का उपयोग करके, जैसे एक्टर्स, और संरचित समन्वय, Swift 6 समन्वय कोड लिखने का एक अधिक सहज और मजबूत तरीका प्रदान करता है, जो दोनों डेवलपर्स उत्पादकता और ऐप स्थिरता में सुधार करता है। async/await मल्टीटास्किंग आधुनिक ऑपरेटिंग सिस्टम और runtimes काम के इकाइयों को एक साथ करने के लिए मल्टीटास्किंग का उपयोग करते हैं. Swift Concurrency सहयोगी मल्टीटास्किंग को अपनाता है, जो ओएस-स्तरीय थ्रेडों द्वारा उपयोग किए जाने वाले पूर्ववर्ती मल्टीटास्किंग मॉडल से मौलिक रूप से भिन्न है. अंतर को समझना एक कुशल और सुरक्षित असंक्रोनिक स्विफ्ट कोड लिखने के लिए महत्वपूर्ण है. Multitasking से बचें Preemptive multitasking ऑपरेटिंग सिस्टम द्वारा थ्रेड्स और प्रक्रियाओं को प्रबंधित करने के लिए उपयोग की जाने वाली मॉडल है. इस मॉडल में, एक सिस्टम-स्तरीय योजनाकार लगभग किसी भी समय किसी भी थ्रेड को हिंसक रूप से बाधित कर सकता है ताकि संदर्भ स्विच किया जा सके और सीपीयू समय को दूसरे थ्रेड को आवंटित किया जा सके. यह पूरे सिस्टम में समानता सुनिश्चित करता है और प्रतिक्रियाशील अनुप्रयोगों की अनुमति देता है - खासकर जब कई उपयोगकर्ता-प्रमुख या समय संवेदनशील कार्यों को संभालते हैं. Preemptive multitasking कई CPU कोरों के बीच सच्ची समानांतरता की अनुमति देता है और गलत व्यवहार या लंबे समय तक चलने वाले तारों को सिस्टम संसाधनों को अवरुद्ध करने से रोकता है. हालांकि, यह लचीलापन एक लागत के साथ आता है. चूंकि तारों को उनके निष्पादन के किसी भी बिंदु पर बाधित किया जा सकता है - यहां तक कि एक महत्वपूर्ण ऑपरेशन के बीच में भी - डेवलपर्स को साझा परिवर्तनीय राज्य की रक्षा करने के लिए सिंक्रनाइज़ेशन प्राइमिटिवेट्स जैसे म्यूटेक्स, सेमेफोर, या परमाणु ऑपरेशन का उपयोग करना होगा. ऐसा करने में विफलता डेटा दौड़, दुर्घटनाओं, या सूक्ष्म बगों का परिणाम हो सकता है जो अ यह मॉडल अधिक नियंत्रण और कच्चे समानता प्रदान करता है, लेकिन यह डेवलपर्स पर भी काफी अधिक बोझ डालता है. एक रोकथाम वातावरण में तार की सुरक्षा सुनिश्चित करना त्रुटियों के प्रति संवेदनशील है और गैर निर्णायक व्यवहार के लिए नेतृत्व कर सकता है - व्यवहार जो चलाने से चलाने तक भिन्न होता है - जिसके बारे में तर्क करना या विश्वसनीय रूप से परीक्षण करना कठिन है। तकनीकी परिप्रेक्ष्य से, पूर्वावलोकन मल्टीटास्किंग थ्रेड निष्पादन को संभालने के लिए ऑपरेटिंग सिस्टम पर भरोसा करता है। ऑपरेटिंग सिस्टम लगभग किसी भी बिंदु पर एक थ्रेड को बाधित कर सकता है - यहां तक कि एक कार्य के बीच में भी - और एक और में स्विच कर सकता है। ऐसा करने के लिए, सिस्टम को एक संदर्भ स्विच करना होगा, जिसमें वर्तमान थ्रेड (जैसे सीपीयू रजिस्टर, निर्देश पेंटर, और स्टैक पेंटर) के पूरे निष्पादन की स्थिति को सहेजने और किसी अन्य थ्रेड के पहले सहेजे गए राज्य को बहाल करना शामिल है। इन ऑपरेशनों में महत्वपूर्ण runtime overhead लागू होता है। प्रत्येक संदर्भ स्विच समय लेता है और सिस्टम संसाधनों का उपभोग करता है – खासकर जब संदर्भ स्विच अक्सर होते हैं या जब कई तार सीमित CPU कोर के लिए प्रतिस्पर्धा करते हैं। यद्यपि यह मॉडल अधिकतम लचीलापन और सच्चे पारंपरिकता प्रदान करता है, यह अक्सर अस्थिर कार्य प्रवाहों के लिए अत्यधिक होता है, जहां कार्य आमतौर पर अपने अधिकांश समय को आई / ओ, उपयोगकर्ता इनपुट, या नेटवर्क प्रतिक्रियाओं की प्रतीक्षा करते हैं, न कि सक्रिय रूप से सीपीयू का उपयोग करते हैं। सहयोगी मल्टीटास्किंग इसके विपरीत, स्विफ्ट का समकक्ष संचालन समय सहयोगी बहुतायत का उपयोग करता है. इस मॉडल में, एक कार्य तब तक चलता है जब तक कि यह स्वयंसेवक नियंत्रण नहीं देता है - आमतौर पर एक इंतजार बिंदु पर या एक स्पष्ट कॉल के माध्यम से पारंपरिक थ्रेड्स के विपरीत, सहयोगी कार्यों को कभी भी मजबूती से अवरुद्ध नहीं किया जाता है. यह भविष्यवाणी योग्य निष्पादन का परिणाम देता है: संदर्भ स्विच केवल स्पष्ट रूप से परिभाषित निलंबन बिंदुओं पर होते हैं। Task.yield() स्विफ्ट के सहयोगी कार्यों को एक हल्के, संचालित संचालित सहयोगी थ्रेड पोल पर निर्धारित किया जाता है - ग्रैंड सेंट्रल डिस्पैच लाइनों से अलग। इस पोल में चलने वाले कार्यों को "अच्छे नागरिकों" होने की उम्मीद है, जब उपयुक्त हो, विशेष रूप से लंबे समय तक चलने वाले या सीपीयू-अनुकूल काम के दौरान नियंत्रण प्रदान करते हैं। एक मैनुअल निलंबन बिंदु के रूप में, यह सुनिश्चित करना कि अन्य कार्यों को निष्पादित करने का मौका है। Task.yield() हालांकि, सहयोगी मल्टीटास्किंग एक चेतावनी के साथ आता है: यदि एक कार्य कभी भी निलंबित नहीं होता है, तो यह उस तार को अकेला कर सकता है जिस पर यह चल रहा है, सिस्टम में अन्य कार्यों को देरी या भूखा कर सकता है। सहयोगी मल्टीटास्किंग में, निष्पादन का मौलिक इकाई एक तार नहीं है, बल्कि काम का एक टुकड़ा है, जिसे अक्सर एक निरंतरता कहा जाता है। कार्य को रोकने के लिए एक , Swift Runtime वर्तमान संचालन स्थिति को एक हेप-अनुदानित निरंतरता में कैप्चर करता है. यह निरंतरता एक पुनरावृत्ति बिंदु का प्रतिनिधित्व करती है और भविष्य के संचालन के लिए निर्धारित होती है. async await एक थ्रेड को एक लंबे समय तक चलने वाले कार्य के साथ जोड़ने के बजाय, स्विफ्ट runtime एक थ्रेड को निरंतरताओं का एक पाइपलाइन के रूप में व्यवहार करता है. प्रत्येक थ्रेड एक निरंतरता को दूसरे के बाद चलाता है. जब एक निरंतरता समाप्त होती है या फिर से निलंबित होती है, तो थ्रेड पंक्ति से अगले तैयार निरंतरता को उठाता है. जैसा कि ऊपर उल्लेख किया गया है, यह मॉडल पारंपरिक ओएस-स्तरीय संदर्भ स्विच से बचता है. सीपीयू रजिस्टर या थ्रेड स्टैक को सहेजने और पुनर्स्थापित करने की कोई आवश्यकता नहीं है; संचालन समय बस अगले बंद होने जैसी निरंतरता को बुलाता है। कुंजी संतुलन: आप थोड़ा अधिक मेमोरी का उपयोग करते हैं, लेकिन कार्य प्रबंधन के लिए नाटकीय रूप से कम ओवरहेड प्राप्त करते हैं। पेश करने के लिए कर्तव्य कर्तव्य स्विट्जरलैंड में, A provides a unit of asynchronous work. Unlike simply calling an कार्य, A एक प्रबंधित वस्तु है जो एक सहयोगी थ्रेड पूल में अन्य कार्यों के साथ साथ-साथ चलती है। Task async Task 💡 कार्यों को एक सहयोगी थ्रेड पूल द्वारा प्रबंधित किया जाता है. सहयोगी थ्रेड पूल को समकक्षता को प्रभावी ढंग से प्रबंधित करने के लिए डिज़ाइन किया गया है, जिससे कार्यों को सीपीयू को निष्पादित करने की अनुमति मिलती है जबकि एसिंक्रनाइज़ ऑपरेशन पूरा होने की प्रतीक्षा होती है. यह एसिंक्रनाइज़ कार्यों और कार्यों के उपयोग के माध्यम से प्राप्त होता है, जो स्विफ्ट में समकक्षता के बुनियादी इकाइयों हैं। 💡 कार्यों को एक सहयोगी थ्रेड पूल द्वारा प्रबंधित किया जाता है. सहयोगी थ्रेड पूल को समकक्षता को प्रभावी ढंग से प्रबंधित करने के लिए डिज़ाइन किया गया है, जिससे कार्यों को सीपीयू को निष्पादित करने की अनुमति मिलती है जबकि एसिंक्रनाइज़ ऑपरेशन पूरा होने की प्रतीक्षा होती है. यह एसिंक्रनाइज़ कार्यों और कार्यों के उपयोग के माध्यम से प्राप्त होता है, जो स्विफ्ट में समकक्षता के बुनियादी इकाइयों हैं। कार्यों को एक साथ चलाने के लिए बनाया जा सकता है, और वे प्रतीक्षा या रद्द भी किया जा सकता है. वे asynchronous व्यवहार पर अच्छी तरह से नियंत्रण प्रदान करते हैं और Swift में संरचित समन्वय का एक अभिन्न हिस्सा हैं. Creating a Task एक कार्य का उपयोग करके बनाया जा सकता है , जो तुरंत प्रदान की गई असंक्रोनिक ऑपरेशन को लॉन्च करता है: Task प्रारंभिक प्रारंभिक Task(priority: .userInitiated) { await fetchData() } When you create a मानक Initializer (यानी नहीं) का उपयोग करें ), it inherits the surrounding actor context, priority, and task-local values. This behavior is crucial for structured concurrency and safety in concurrent code. Task अलग अलग 💡 Swift 6.2 एक महत्वपूर्ण बदलाव लाता है कि कॉर्पोरेट का प्रबंधन कैसे किया जाता है: डिफ़ॉल्ट रूप से, सभी कोड MainActor पर चलते हैं। पृष्ठभूमि पर कोड चलाने के लिए, Swift 6.2 एक नया गुण @concurrent जोड़ता है। 💡 Swift 6.2 एक महत्वपूर्ण बदलाव लाता है कि कॉर्पोरेट का प्रबंधन कैसे किया जाता है: डिफ़ॉल्ट रूप से, सभी कोड MainActor पर चलते हैं। पृष्ठभूमि पर कोड चलाने के लिए, Swift 6.2 एक नया गुण @concurrent जोड़ता है। WWDC स्विफ्ट प्रतिस्पर्धा को शामिल करता है WWDC स्विफ्ट प्रतिस्पर्धा को शामिल करता है कैप के तहत, Swift Concurrency के पुराने संस्करणों में, Swift runtime ने एक आंतरिक तंत्र का उपयोग किया जिसे Swift Concurrency कहा जाता है। to track which actor a task was associated with. Although this property wasn’t part of the public API, it played a key role in ensuring that tasks created inside actor-isolated code would execute on the same actor, preserving data race safety. @_inheritActorContext Swift में प्रगति के साथ, runtime से संक्रमण शुरू हो गया है एक नई प्रणाली के रूप में जाना जाता है , जिसे अब कॉपीराइटर और रनटाइम द्वारा अधिक स्पष्ट रूप से संसाधित किया जाता है। @_inheritActorContext sending 💡 क्या भेजना है? भेजना एक नया कुंजी शब्द है जिसे स्विफ्ट 6 में सुरक्षित और अधिक स्पष्ट समानता के लिए भाषा के कदम के हिस्से के रूप में पेश किया गया है। इसका उपयोग फ़ंक्शन पैरामीटरों को चिह्नित करने और समानता सीमाओं पर स्थानांतरित किए गए मानों को वापस करने के लिए किया जाता है। यह विशेष रूप से अच्छी तरह से काम करता है गैर-कोपाई योग्य प्रकार, स्मृति की सुरक्षा सुनिश्चित करता है और उपयोग के बाद स्थानांतरण त्रुटियों को रोकता है. जब एक पैरामीटर भेजने के साथ चिह्नित किया जाता है, तो कॉम्पेलर यह सुनिश्चित करता है कि स्थानांतरण के बाद मूल संस्करण का उपयोग नहीं किया जाता है। func process(_ data: sending MyNonCopyableType) async { // `data` is moved here and can’t be used elsewhere after the call } 💡 क्या भेजना है? भेजना एक नया कुंजी शब्द है जिसे स्विफ्ट 6 में सुरक्षित और अधिक स्पष्ट समानता के लिए भाषा के कदम के हिस्से के रूप में पेश किया गया है। इसका उपयोग फ़ंक्शन पैरामीटरों को चिह्नित करने और समानता सीमाओं पर स्थानांतरित किए गए मानों को वापस करने के लिए किया जाता है। यह विशेष रूप से अच्छी तरह से काम करता है गैर-कोपाई योग्य प्रकार, स्मृति की सुरक्षा सुनिश्चित करता है और उपयोग के बाद स्थानांतरण त्रुटियों को रोकता है. जब एक पैरामीटर भेजने के साथ चिह्नित किया जाता है, तो कॉम्पेलर यह सुनिश्चित करता है कि स्थानांतरण के बाद मूल संस्करण का उपयोग नहीं किया जाता है। func process(_ data: sending MyNonCopyableType) async { // `data` is moved here and can’t be used elsewhere after the call } जब आप एक लॉन्च करते हैं , you must ensure that any values captured by the task are कॉपीराइटर अब कॉपीराइटर-टाइम का उपयोग करते समय यह लागू करता है प्रोटोकॉल और कार्य प्रकार। Task.detached Sendable Sendable @Sendable अनुरूप नहीं होने से एक compile-time त्रुटि का परिणाम हो सकता है, विशेष रूप से सख्त concurrency मोड में। Sendable कार्य प्राथमिकताओं का भी समर्थन करते हैं, जैसे कि ग्रैंड सेंट्रल डिस्पैच की लाइन उन्हें संभालती है। केस Task Task.detached Swift Concurrency के साथ काम करते समय, अंतर को समझना महत्वपूर्ण है और , क्योंकि वे परिभाषित करते हैं कि कैसे और कहाँ एसिंक्रोनिक काम किया जाता है। Task Task.detached Task कर्तव्य वर्तमान संदर्भ (जैसे या किसी भी कस्टम अभिनेता) और प्राथमिकता. यह आमतौर पर उपयोग किया जाता है जब आप एक नया असंक्रोनिक ऑपरेशन पैदा करना चाहते हैं जो अभी भी वर्तमान संरचित समानता पेड़ या अभिनेता अलगाव का सम्मान करता है. यह विशेष रूप से यूआई अद्यतनों या विशिष्ट समानता डोमेन के भीतर काम करने के लिए उपयोगी है. Task MainActor Task { await updateUI() } उपर्युक्त उदाहरण में, यदि मुख्य अभिनेता से कॉल किया जाता है, तो will also run on the main actor unless explicitly moved elsewhere. Task Task.detached डिस्चार्ज यह एक पूरी तरह से स्वतंत्र कार्य बनाता है. यह वर्तमान अभिनेता संदर्भ या प्राथमिकता को विरासत में नहीं लेता है. इसका मतलब है कि यह एक वैश्विक समकक्ष संदर्भ में शुरू होता है और विशेष रूप से साझा डेटा तक पहुंचने पर सुरक्षा प्रबंधन की आवश्यकता होती है. Task.detached Task.detached { await performBackgroundWork() } उपयोग करें जब आपको वर्तमान संरचित संदर्भ के बाहर पृष्ठभूमि ऑपरेशन चलाने की आवश्यकता होती है, जैसे कि लंबे समय तक चलने वाले गणनाएं या एक अभिनेता की अलगाव से बचना। Task.detached Thread Pool के बारे में Swift Concurrency में एक सहकारी थ्रेड पूल एक तंत्र है जो सीमित संख्या में थ्रेडों पर उन्हें व्यवस्थित करके असंगत कार्यों को निष्पादित करने का प्रबंधन करता है, आमतौर पर सीपीयू कोर की संख्या से मेल खाता है। A Cooperative Thread Pool in Swift Concurrency is a mechanism that manages the execution of asynchronous tasks by scheduling them onto a limited number of threads, typically matching the number of CPU cores. Swift Concurrency operates using cooperative thread pool designed for efficient scheduling and minimal thread overhead. Unlike traditional thread-per-task executing model, Swift’s approach emphasizes structured concurrency and resource-aware scheduling. एक आम अत्यधिक सरलता यह कहने के लिए है कि Swift Concurrency प्रत्येक कोर पर एक तार का उपयोग करता है, जो संदर्भ स्विच को कम करने और सीपीयू उपयोग को अधिकतम करने के अपने लक्ष्य के अनुरूप है. हालांकि यह दृष्टिकोण सख्त रूप से गलत नहीं है, यह सेवा की गुणवत्ता के बक्से, कार्य प्राथमिकताओं और डार्विन योजनाकार व्यवहार के बारे में महत्वपूर्ण बारीकियों को छोड़ देता है. Thread Count: इतना सरल नहीं Thread Count: इतना सरल नहीं एक 16 कोर मैक पर, यह केवल Swift Concurrency द्वारा प्रबंधित 64 तारों तक का निरीक्षण करना संभव है - जीसीडी की भागीदारी के बिना। Formally: Max threads = (CPU cores) × (dedicated quality-of-service buckets) इस प्रकार, 16 कोर सिस्टम पर: 16 cores × 4 QoS buckets = 64 threads प्रत्येक QoS बैकेट मूल रूप से एक समर्पित थ्रेड लाइन है जो एक समूह कार्यों के लिए एक समान निष्पादन प्राथमिकता साझा करता है. ये डार्विन के थ्रेड योजना तंत्र द्वारा आंतरिक रूप से प्रबंधित होते हैं और जीसीडी पंक्तियों के समान नहीं होते हैं। QoS बक्से और कार्य प्राथमिकता QoS बक्से और कार्य प्राथमिकता हालांकि इनमें से छह संस्करण हैं, जिनमें से कुछ निम्नलिखित हैं: TaskPriority ऊंचाई से शुरू होता है कम उपयोगी डिफ़ॉल्ट → पहले से ही मध्यम में मैप किया गया है कोरल की परिप्रेक्ष्य के लिए, यह 4 कोर प्राथमिकता स्तरों को सरल बनाता है, प्रत्येक को एक QoS बैकेट में माप दिया जाता है, जो सहकारी थ्रेड पूल में थ्रेड वितरण को प्रभावित करता है। Overcommit कब होता है? When Does Overcommit Happen? सामान्य भार के तहत, Swift Concurrency सहयोगी पूल सीमाओं का सम्मान करता है. हालांकि, विवाद के तहत (उदाहरण के लिए, उच्च प्राथमिकता वाले कार्य कम प्राथमिकता वाले कार्यों के लिए प्रतीक्षा करते हैं), सिस्टम प्रतिक्रिया को बनाए रखने के लिए तारों को ओवरकॉम कर सकता है. यह गतिशील समायोजन यह सुनिश्चित करता है कि समय संवेदनशील कार्यों को कम प्राथमिकता वाले कार्यों के पीछे असीमित समय तक अवरुद्ध नहीं किया जाता है. इस व्यवहार को मैच योजना नीतियों और उच्च प्राथमिकता के माध्यम से डार्विन कोर द्वारा प्रबंधित किया जाता है lanes - not something controlled explicitly by your code. pthreads Task Priority स्विफ्ट कार्यों के लिए एक प्राथमिकता प्रणाली प्रदान करता है, ग्रैंड सेंट्रल डिस्पैच (जीसीडी) के समान है, लेकिन संरचित समन्वय मॉडल में अधिक सेमेंटिक रूप से एकीकृत है। शुरुआत करें : Task Task(priority: .userInitiated) { await loadUserData() } उपलब्ध प्राथमिकताओं को परिभाषित किया जाता है एकमात्र: TaskPriority Priority Description / .high .userInitiated For tasks initiated by user interaction that require immediate feedback. .medium For tasks that the user is not actively waiting for. / .low .utility For long-running tasks that don’t require immediate results, such as copying files or importing data. .background For background tasks that the user is not directly aware of. Primarily used for work the user cannot see. / के .high .userInitiated उपयोगकर्ता बातचीत द्वारा शुरू किए गए कार्यों के लिए जिन्हें तत्काल प्रतिक्रिया की आवश्यकता होती है। .medium उन कार्यों के लिए जो उपयोगकर्ता सक्रिय रूप से इंतजार नहीं कर रहा है। / के .low .utility लंबे समय तक चलने वाली कार्यों के लिए जिनके लिए तुरंत परिणाम की आवश्यकता नहीं होती है, जैसे फ़ाइलों को कॉपी करना या डेटा आयात करना। .background पृष्ठभूमि कार्यों के लिए जिन्हें उपयोगकर्ता सीधे नहीं जानता है. मुख्य रूप से काम के लिए उपयोग किया जाता है जिसे उपयोगकर्ता नहीं देख सकता है. विभिन्न प्राथमिकताओं के साथ कार्यों का निर्माण विभिन्न प्राथमिकताओं के साथ कार्यों का निर्माण When you create a एक अन्य कार्य के भीतर (अनुमानित) priority), you can explicitly set a different priority for each nested task. Here, one child task is , और दूसरा है .high. यह दिखाता है कि प्राथमिकताएं माता-पिता के बावजूद व्यक्तिगत रूप से निर्धारित की जा सकती हैं। Task .medium .low Task { // .medium by default Task(priority: .low) { print("\(1), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } Task(priority: .high) { print("\(2), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } } // 1, thread: <_NSMainThread: 0x6000017040c0>{number = 1, name = main}, priority: TaskPriority.low // 2, thread: <_NSMainThread: 0x6000017040c0>{number = 1, name = main}, priority: TaskPriority.high If you don’t explicitly set a priority for a nested task, it inherits the priority of its immediate parent. In this example, the anonymous tasks inside और ब्लॉक इन प्रासंगिक प्राथमिकताओं को विरासत में रखते हैं, जब तक कि वे अधिभार न हों। .high .low कार्य प्राथमिकताओं को विरासत में किया जा सकता है Task Priorities Can Be Inherited Task { Task(priority: .high) { Task { print("\(1), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } } Task(priority: .low) { print("\(2), "thread: \(Thread.current)", priority: \(Task.currentPriority)") Task { print("\(3), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } Task(priority: .medium) { print("\(4), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } } } // 2, thread: <_NSMainThread: 0x600001708040>{number = 1, name = main}, priority: TaskPriority.low // 1, thread: <_NSMainThread: 0x600001708040>{number = 1, name = main}, priority: TaskPriority.high // 3, thread: <_NSMainThread: 0x600001708040>{number = 1, name = main}, priority: TaskPriority.low // 4, thread: <_NSMainThread: 0x600001708040>{number = 1, name = main}, priority: TaskPriority.medium यदि आप एक निहित कार्य के लिए स्पष्ट रूप से प्राथमिकता निर्धारित नहीं करते हैं, तो यह उसके तत्काल माता-पिता की प्राथमिकता का वारंटी देता है. इस उदाहरण में, .high और .low ब्लॉकों के भीतर अनन्य कार्य उन प्रासंगिक प्राथमिकताओं का वारंटी देते हैं, जब तक कि वे अवर्रेड न हों. कर्तव्यों को बढ़ावा देने की प्राथमिकता कर्तव्यों को बढ़ावा देने की प्राथमिकता Task(priority: .high) { Task { print("\(1), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } await Task(priority: .low) { print("\(2), "thread: \(Thread.current)", priority: \(Task.currentPriority)") await Task { print("\(3), "thread: \(Thread.current)", priority: \(Task.currentPriority)") }.value Task(priority: .medium) { print("\(4), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } }.value } // 1, thread: <_NSMainThread: 0x6000017000c0>{number = 1, name = main}, priority: TaskPriority.high // 2, thread: <_NSMainThread: 0x6000017000c0>{number = 1, name = main}, priority: TaskPriority.high // 3, thread: <_NSMainThread: 0x6000017000c0>{number = 1, name = main}, priority: TaskPriority.high // 4, thread: <_NSMainThread: 0x6000017000c0>{number = 1, name = main}, priority: TaskPriority.medium इस तंत्र को प्राथमिकता एस्केलेशन कहा जाता है - जब एक कार्य को एक उच्च प्राथमिकता कार्य द्वारा प्रतीक्षित किया जाता है, तो सिस्टम अस्थायी रूप से अपनी प्राथमिकता बढ़ा सकता है ताकि बोतलों से बचें और प्रतिक्रिया सुनिश्चित हो सके। परिणाम के रूप में: कार्य 2, जो .low है, प्रतीक्षा के दौरान .high तक बढ़ जाता है। कार्य 3, जिसके पास स्पष्ट प्राथमिकता नहीं है, उसके मातृ प्राथमिकता (ट्यूशन 2) से एस्केलेटेड प्राथमिकता विरासत देता है और .highpriority के साथ भी संचालित होता है। कार्य 4 स्पष्ट रूप से .medium को प्राथमिकता देता है, इसलिए इसे एस्केलेशन से प्रभावित नहीं होता है। प्राथमिकता प्राप्त नहीं करती है डिस्चार्ज डिस्चार्ज अधिनियम ( ) run independently and do not inherit the priority of their parent task. They behave like global tasks with their own scheduling. This is useful for isolating background work, but can also lead to unexpected priority mismatches if not set manually. Task.detached Task(priority: .high) { Task.detached { print("\(1), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } Task(priority: .low) { print("\(2), "thread: \(Thread.current)", priority: \(Task.currentPriority)") Task.detached { print("\(3), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } Task(priority: .medium) { print("\(4), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } } } // 1, thread: <NSThread: 0x60000174dec0>{number = 4, name = (null)}, priority: TaskPriority.medium // 2, thread: <_NSMainThread: 0x600001708180>{number = 1, name = main}, priority: TaskPriority.low // 3, thread: <NSThread: 0x60000174dec0>{number = 4, name = (null)}, priority: TaskPriority.medium // 4, thread: <_NSMainThread: 0x600001708180>{number = 1, name = main}, priority: TaskPriority.medium निलंबन बिंदु और कैसे स्विफ्ट Async निष्पादन का प्रबंधन करता है Swift में, किसी भी कॉल को एक काम का उपयोग यह एक संभावित निलंबन बिंदु है - फ़ंक्शन में एक जगह जहां निष्पादन रुक सकता है और बाद में फिर से शुरू हो सकता है. यह एक परिवर्तन है जिसमें फ़ंक्शन की स्थिति को सहेजने शामिल है ताकि प्रतीक्षित ऑपरेशन पूरा होने के बाद इसे बाद में फिर से शुरू किया जा सके. async await Here’s an example: func fetchData() async -> String { let result = await networkClient.load() return result } इस मामले में, जब कार्य इस लाइन तक पहुंचता है, तो यह निष्पादन को रोक सकता है, सिस्टम को नियंत्रण दे सकता है, और बाद में एक बार फिर से शुरू कर सकता है दृश्यों के पीछे, संकलक इस कार्य को एक राज्य मशीन में परिवर्तित करता है जो इसकी प्रगति और आंतरिक परिवर्तकों को ट्रैक करता है। await networkClient.load() load() कैप के तहत: निरंतरता और राज्य मशीनरी हर Swift में फ़ंक्शन को एक राज्य मशीन में संकलित किया जाता है। एक बिंदु पर पहुंचने से पहले, एक तेजी से : async await await फंक्शन की वर्तमान स्थिति को सहेजता है - स्थानीय परिवर्तकों और वर्तमान निर्देश पेंटर सहित। निष्पादन को निलंबित करता है और एक निरंतरता की योजना बनाता है। एक बार जब async ऑपरेशन पूरा हो जाता है, तो यह उस जगह से कार्य को फिर से शुरू करता है जहां यह बंद हो गया था। यह कई कार्यात्मक प्रोग्रामिंग प्रणालियों में उपयोग किए जाने वाले निरंतरता पारित करने वाले शैली (सीपीएस) के समान है. Swift के समकक्षता मॉडल में, यह आंतरिक प्रकारों द्वारा संचालित किया जाता है जैसे कि प्रतिस्पर्धी समय की योजना बनाएं। ParticialAsyncTask अवरोध ! = अवरोध जब आप Swift में कुछ है, वर्तमान थ्रेड अवरुद्ध नहीं है, इसके बजाय: await वर्तमान कार्य निष्पादक को नियंत्रण वापस देता है इंतजार करते समय अन्य कार्य चला सकते हैं जब प्रतीक्षित ऑपरेशन पूरा हो जाता है, तो उचित निष्पादक पर निलंबित कार्य फिर से शुरू होता है। यह बनाता है तार-आधारित ब्लॉकिंग ऑपरेशनों की तुलना में मूल रूप से अधिक कुशल और स्केलिंग योग्य . async/await DispatchQueue.sync : अन्य कार्यों को चलाने के लिए वजन घटाने ( वजन घटाने ( is a static method provided by Swift’s concurrency system that voluntarily suspends the current task, giving the system opportunity to run other enqueued tasks. It’s especially useful in long-running asynchronous operations or tight loops that don’t naturally contains suspension points. Task.yield() func processLargeBatch() async { for i in 0..<1_000_000 { if i % 10_000 == 0 { await Task.yield() } } } बिना , यह लूप executor को monopolize करेगा। समय-समय पर, आप स्विफ्ट के समकक्ष संचालन समय के साथ सहयोग कर रहे हैं, जिससे प्रतिक्रियाशीलता और निष्पक्षता बनाए रखने की अनुमति मिलती है। await await Task.yield() हेड के तहत इंतजार करने के लिए कॉल वर्तमान कार्य को निलंबित करता है और इसे अपने वर्तमान निष्पादक (उदाहरण के लिए, मुख्य अभिनेता या वैश्विक समकक्ष निष्पादक) के लिए पंक्ति के अंत में फिर से संलग्न करता है। Task.yield() It’s part of Swift’s cooperative multitasking model: tasks run to the next suspension point and are expected to yield fairly. Unlike preemptive systems (e.g., threads), Swift tasks don’t get forcibly interrupted — they must voluntarily yield control. संक्षेप स्विफ्ट 6 प्रबंधन के तरीके में एक महत्वपूर्ण कदम है, डेवलपर्स को अधिक नियंत्रण, पूर्वानुमान और सुरक्षा प्रदान करता है. जबकि सीखने की कुंजी शुरू में धीमी हो सकती है, इन अवधारणाओं को समझने के लिए अत्यधिक प्रतिक्रियाशील और मजबूत अनुप्रयोगों का निर्माण करने के लिए दरवाजा खोलता है. जैसा कि हम स्विफ्ट के नए स्विफ्ट मॉडल के गहरे पहलुओं का पता लगाना जारी रखते हैं, यह स्पष्ट है कि ये बदलाव सुरक्षित और स्केलेबल ऐप विकास के भविष्य के लिए नींव लगाते हैं।
