Async/Await: सार, async फ़ंक्शन और await के साथ काम करना

Async/Await और अतुल्यकालिक प्रोग्रामिंग क्या है?

Async/Await एक भाषा निर्माण है जो आपको अतुल्यकालिक कोड को समकालिक कोड जितना ही रैखिक रूप से लिखने की अनुमति देता है। Swift में, यह iOS 13 / macOS 10.15 में Swift Concurrency फ्रेमवर्क के साथ दिखाई दिया। Kotlin में, async/await संस्करण 1.3 से कोरूटीन लाइब्रेरी (kotlinx.coroutines) के माध्यम से उपलब्ध है।

async/await से पहले, अतुल्यकालिक कोड कॉलबैक, GCD या RxSwift पर बनाया जाता था। नेस्टेड कॉलबैक की श्रृंखलाओं ने कॉलबैक हेल को जन्म दिया — गहरी नेस्टिंग जो पढ़ने और डीबग करने को जटिल बनाती है। Async/Await इस समस्या को हल करता है, अतुल्यकालिक फ़ंक्शन को await बिंदुओं पर “रुकने” और परिणाम प्राप्त करने के बाद फिर से शुरू करने की अनुमति देता है।

Google (2025) के अनुसार, Kotlin में async/await का उपयोग कॉलबैक दृष्टिकोण की तुलना में अतुल्यकालिक कोड की पंक्तियों को 40–60% तक कम करता है। Swift में, Swift Concurrency अपनाने की दर 2025 में प्रकाशित अनुप्रयोगों में 68% तक पहुँच गई। iOS 16 ने UIKit, SwiftUI और Foundation में Swift Concurrency समर्थन जोड़ा, जिससे async/await सभी नए Apple प्रोजेक्ट्स के लिए मानक उपकरण बन गया।

संचालन सिद्धांत: रोके जाने योग्य फ़ंक्शन

async/await और थ्रेड के बीच मुख्य अंतर बिना ब्लॉकिंग के रुकना है। जब कोई फ़ंक्शन await का सामना करता है, तो यह रुक जाता है, वर्तमान थ्रेड को अन्य कार्यों के लिए मुक्त करता है। अतुल्यकालिक कार्य पूरा होने के बाद, फ़ंक्शन उसी या अलग थ्रेड पर फिर से शुरू होता है। इसे सहकारी मल्टीटास्किंग कहा जाता है।

Async/Await कैसे काम करता है: रोकना और पुनः शुरू करना

एक async फ़ंक्शन को एक स्टेट मशीन में संकलित किया जाता है — एक सीमित ऑटोमेटन जो निष्पादन राज्यों का प्रबंधन करता है। await बिंदु पर, कंपाइलर संदर्भ (स्थानीय चर, वापसी पता) सहेजता है और नियंत्रण रनटाइम को सौंपता है। जब परिणाम तैयार होता है, रनटाइम संदर्भ को पुनर्स्थापित करता है और निष्पादन जारी रखता है।

Swift में, यह स्टेट मशीन SIL (Swift Intermediate Language) कंपाइलर स्तर पर कार्यान्वित की जाती है। Kotlin में, Continuation Passing Style (CPS) तंत्र का उपयोग किया जाता है: प्रत्येक सस्पेंड फ़ंक्शन एक छिपा हुआ Continuation पैरामीटर स्वीकार करता है जिसके माध्यम से परिणाम वापस किया जाता है। दोनों दृष्टिकोण मेमोरी लीक के बिना सुरक्षित पुनः शुरू करने की गारंटी देते हैं।

• Swift — कंपाइलर async फ़ंक्शन को runAsync कोरूटीन फ्रेम के साथ SIL में अनुवादित करता है
• Kotlin — प्रत्येक सस्पेंड फ़ंक्शन एक Continuation प्राप्त करता है और निष्पादन डिस्पैचर को सौंपता है
• दोनों भाषाएँ — await पर थ्रेड को मुक्त करती हैं, प्रतीक्षा के दौरान उसे ब्लॉक नहीं करतीं
• अपवाद — मानक तंत्र (throws / try-catch) के माध्यम से प्रसारित होते हैं

Async/Await बनाम कॉलबैक और GCD: दृष्टिकोण तुलना

कॉलबैक दृष्टिकोण में एक क्लोज़र पास करने की आवश्यकता होती है जो कार्य पूरा होने के बाद कॉल किया जाता है। तीन अनुक्रमिक अनुरोधों के साथ, आपको प्रत्येक स्तर पर त्रुटि प्रबंधन के साथ तीन स्तरों की नेस्टिंग मिलती है। Async/Await उन्हीं तीन अनुरोधों को एकल catch ब्लॉक के साथ तीन अनुक्रमिक पंक्तियों में बदल देता है।

GCD (DispatchQueue) सीरियल क्यू और DispatchGroup के माध्यम से कॉलबैक हेल को हल करता है, लेकिन वर्बोज़ बना रहता है। एक साधारण कार्य के लिए — उपयोगकर्ता लोड करें, फिर मित्र, फिर UI — क्यू, समूह और notify ब्लॉक बनाने की आवश्यकता होती है। Async/Await एक ही फ़ंक्शन में तीन पंक्तियों के साथ वही कार्य करता है।

Apple WWDC 2024 के अनुसार, Swift Concurrency async/await नए कोड के लिए अनुशंसित दृष्टिकोण है। GCD C लाइब्रेरी के साथ एकीकरण और विशिष्ट निम्न-स्तरीय थ्रेड हैंडलिंग परिदृश्यों के लिए बना हुआ है।

Swift Concurrency: Task, TaskGroup और Actor

Task Swift में अतुल्यकालिक कार्य की मूल इकाई है। Task किसी मौजूदा एक्टर के संदर्भ में या किसी भी थ्रेड पर बनाया जाता है। Task के अंदर, await के माध्यम से async फ़ंक्शन कॉल किए जा सकते हैं। TaskGroup कई चाइल्ड कार्यों को समानांतर में शुरू करने और उनके परिणाम एकत्र करने की अनुमति देता है — यह DispatchGroup का उन्नत संस्करण है।

Actor एक थ्रेड-सुरक्षित संदर्भ प्रकार है जो अपनी स्थिति को डेटा रेस से बचाता है। कंपाइलर गारंटी देता है कि एक्टर गुणों तक पहुँच केवल async कॉल या एक्टर आइसोलेशन के भीतर ही संभव है। Actor मैन्युअल लॉक के बिना साझा परिवर्तनीय स्थिति की सुरक्षा के लिए सीरियल DispatchQueue को बदलता है।

Structured Concurrency

Structured Concurrency का सिद्धांत कहता है: प्रत्येक अतुल्यकालिक कार्य का एक जनक होता है, और जनक तब तक पूरा नहीं होता जब तक उसके सभी बच्चे पूरे नहीं हो जाते। यदि कार्य A Task { await B() } शुरू करता है, तो A B की प्रतीक्षा करता है। यह कार्य लीक को रोकता है और एक पूर्वानुमानित जीवनचक्र सुनिश्चित करता है।

Kotlin में कोरूटीन के साथ Async/Await

Kotlin में, async/await कोरूटीन के माध्यम से कार्यान्वित किया जाता है — भाषा के हल्के थ्रेड। एक फ़ंक्शन को suspend कीवर्ड से चिह्नित किया जाता है (Swift के async के अनुरूप)। लॉन्च करने के लिए launch (फायर-एंड-फ़ॉरगेट) या async (परिणाम के साथ) का उपयोग किया जाता है। Async से परिणाम प्राप्त करने के लिए Await कहा जाता है।

Dispatcher निर्धारित करता है कि कोरूटीन किस थ्रेड पूल पर चलता है: UI के लिए Dispatchers.Main, नेटवर्क/डिस्क के लिए Dispatchers.IO और CPU-गहन कार्यों के लिए Dispatchers.Default। Structured Concurrency CoroutineScope के माध्यम से सुनिश्चित किया जाता है — जब स्कोप रद्द होता है, तो सभी चाइल्ड कोरूटीन रद्द हो जाते हैं।

JetBrains (2025) के अनुसार, Google Play पर 97% Android ऐप्स kotlinx.coroutines का उपयोग करते हैं, और उनमें से 82% नेटवर्क अनुरोधों के लिए async/await लागू करते हैं। कोरूटीन Android में अतुल्यकालिक प्रोग्रामिंग के लिए डी-फैक्टो मानक बन गए हैं। Kotlin Multiplatform भी कोरूटीन का समर्थन करता है, जिससे Android, iOS और सर्वर साइड पर साझा अतुल्यकालिक कोड का उपयोग संभव होता है।

Swift और Kotlin में Async/Await के साथ कोड उदाहरण

आइए प्रत्येक भाषा के लिए दो उदाहरण देखें: अनुक्रमिक डेटा लोडिंग और TaskGroup या async/await के साथ समानांतर अनुरोध।

Swift: अनुक्रमिक async कॉल

await उपयोगकर्ता डेटा प्राप्त होने तक, फिर मित्र प्राप्त होने तक निष्पादन रोकता है। कोई नेस्टेड क्लोज़र नहीं।

func loadProfile() async throws -> Profile {
    let user = try await api.fetchUser()
    let friends = try await api.fetchFriends(for: user.id)
    return Profile(user: user, friends: friends)
}

Swift: TaskGroup के साथ समानांतर अनुरोध

TaskGroup कार्यों को समानांतर में शुरू करता है और परिणामों को एक सरणी में एकत्र करता है। परिणामों का क्रम शुरू करने के क्रम से मेल नहीं खा सकता।

func loadParallel() async throws -> [String] {
    await withThrowingTaskGroup(of: String.self) { group in
        group.addTask { try await api.fetchName() }
        group.addTask { try await api.fetchEmail() }
        group.addTask { try await api.fetchAvatar() }
        var results = [String]()
        for try await value in group { results.append(value) }
        return results
    }
}

Kotlin: async/await के साथ अनुक्रमिक कॉल

suspend फ़ंक्शन अन्य suspend फ़ंक्शन कॉल कर सकते हैं। Swift के अनुरूप: अनुक्रमिक कॉल।

suspend fun loadProfile(): Profile {
    val user = api.fetchUser()
    val friends = api.fetchFriends(user.id)
    return Profile(user, friends)
}

Kotlin: async/await के साथ समानांतर अनुरोध

Kotlin में, समानांतरता प्रत्येक अनुरोध के लिए async के साथ coroutineScope के माध्यम से प्राप्त की जाती है।

suspend fun loadParallel(): List<String> = coroutineScope {
    val name = async { api.fetchName() }
    val email = async { api.fetchEmail() }
    val avatar = async { api.fetchAvatar() }
    listOf(name.await(), email.await(), avatar.await())
}

Async/Await की सामान्य गलतियाँ और सीमाएँ

भूला हुआ Task { } — एक async फ़ंक्शन को Task में लपेटे बिना समकालिक संदर्भ से नहीं बुलाया जा सकता। Swift में, यह त्रुटि के साथ संकलित होता है। Kotlin में, lifecycleScope या viewModelScope के माध्यम से लॉन्च करने की आवश्यकता होती है। सामान्य फ़ंक्शन से suspend फ़ंक्शन कॉल करने का प्रयास संकलित नहीं होगा।

बिना आवश्यकता के async का अत्यधिक उपयोग

हर फ़ंक्शन को अतुल्यकालिक बनाने की आवश्यकता नहीं है। I/O के बिना CPU-गहन कार्य async से लाभ नहीं उठाते — उन्हें .userInitiated QoS के साथ DispatchQueue पर निष्पादित करना बेहतर है। Async/Await I/O-बाउंड संचालन के लिए अनुकूलित है: नेटवर्क, डिस्क, प्रतीक्षा।

.result के माध्यम से मुख्य थ्रेड को ब्लॉक करना

मुख्य थ्रेड पर .result का उपयोग (async फ़ंक्शन के परिणाम की समकालिक प्रतीक्षा) ब्लॉकिंग की ओर ले जाता है। Swift में, Task.synchronousWait Apple द्वारा अनुशंसित नहीं है। Kotlin में, मुख्य थ्रेड पर runBlocking एक एंटीपैटर्न है — lifecycleScope का उपयोग करें।

रद्दीकरण पर Task लीक

यदि Task को क्लास प्रॉपर्टी में सहेजा नहीं जाता है, तो संदर्भ से बाहर निकलने पर यह रद्द हो जाता है। Swift में, Task स्कोप्ड है — इसका जीवनचक्र बनाने वाले संदर्भ से जुड़ा होता है। लंबे समय तक चलने वाले कार्य के लिए Task को प्रॉपर्टी में सहेजें।