async: यह क्या है, Deferred और समानांतर कोरूटिन कैसे काम करते हैं

Kotlin Coroutines में async क्या है?

async — CoroutineScope का एक विस्तार फ़ंक्शन है जो परिणाम लौटाने वाली कोरूटिन बनाता है। launch के विपरीत, async Deferred<T> लौटाता है — एक ऐसा ऑब्जेक्ट जो भविष्य के मान का प्रतिनिधित्व करता है। async के माध्यम से शुरू की गई कोरूटिन अन्य कोरूटिनों के साथ समवर्ती रूप से चलती है, जिससे गणनाओं को समांतरित किया जा सकता है।

async का उपयोग तब किया जाता है जब आगे की प्रसंस्करण के लिए एक असिंक्रोनस ऑपरेशन का परिणाम आवश्यक होता है: एकाधिक स्रोतों से डेटा लोड करना, संग्रहों का बैच प्रसंस्करण, विभिन्न API को समानांतर अनुरोध। Deferred तुरंत बनाया जाता है, और कोरूटिन पूर्ण होने के बाद परिणाम उपलब्ध होता है।

import kotlinx.coroutines.*

suspend fun String.delayedValue(): String {
    delay(1000L)
    return this
}

fun main() = runBlocking {
    val deferred: Deferred<String> = async { "Hello".delayedValue() }
    println(deferred.await())
}

async और Deferred का सिंटैक्स

async का हस्ताक्षर launch के समान है: वही CoroutineContext, CoroutineStart पैरामीटर और एक suspend ब्लॉक। अंतर रिटर्न प्रकार में है — Job के बजाय Deferred<T>, जहाँ T ब्लॉक के अंतिम एक्सप्रेशन द्वारा लौटाया गया परिणाम प्रकार है।

public fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred<T>

Deferred<T> — एक इंटरफ़ेस जो Job से विरासत पाता है और await(), getCompleted(), getCompletionExceptionOrNull() विधियाँ जोड़ता है। await() एक suspend फ़ंक्शन है और केवल कोरूटिन या किसी अन्य suspend फ़ंक्शन के अंदर ही बुलाया जा सकता है। getCompleted() एक गैर-अवरोधक विधि है जो अपवाद फेंकती है यदि कोरूटिन अभी पूर्ण नहीं हुई है।

async के साथ समानांतर कार्य

async का मुख्य लाभ कार्यों को समानांतर चलाने की क्षमता है। प्रत्येक ऑपरेशन के अनुक्रमिक रूप से प्रतीक्षा करने के बजाय (कुल समय = समयों का योग), async एकसाथ कोरूटिन शुरू करता है, जिससे कुल समय घटकर सबसे लंबे ऑपरेशन की अवधि के बराबर रह जाता है।

समानांतर डेटा लोडिंग

एक सामान्य परिदृश्य — तीन समानांतर async अनुरोधों के साथ उपयोगकर्ता प्रोफ़ाइल, उनकी सेटिंग्स और ऑर्डर हिस्ट्री लोड करना। तीनों के पूर्ण होने के बाद, परिणाम एक ही डेटा मॉडल में संयुक्त हो जाते हैं।

suspend fun loadUserDashboard(userId: String): Dashboard = coroutineScope {
    val profile = async { api.getProfile(userId) }
    val settings = async { api.getSettings(userId) }
    val orders = async { api.getRecentOrders(userId) }

    Dashboard(
        profile = profile.await(),
        settings = settings.await(),
        orders = orders.await()
    )
}

coroutineScope फ़ंक्शन चाइल्ड कोरूटिन शुरू करता है और परिणाम लौटाने से पहले उनके पूर्ण होने की प्रतीक्षा करता है। पूरा ब्लॉक अनुक्रमिक रूप से नहीं, बल्कि समानांतर रूप से निष्पादित होता है।

Deferred परिणामों का प्रबंधन

Deferred परिणाम के साथ कार्य करने के लिए अनेक विधियों का समर्थन करता है। await() के अलावा, स्थिति की जाँच करने, पूर्ण मान प्राप्त करने और Kotlin Coroutines उपयोगिता फ़ंक्शनों के माध्यम से एकाधिक Deferred को एकत्र करने के लिए विधियाँ उपलब्ध हैं।

Deferred की सूची को एकत्र करने के लिए, awaitAll() का उपयोग किया जाता है — एक फ़ंक्शन जो संग्रह में सभी Deferred के पूर्ण होने तक निष्पादन को रोकता है। यदि कम से कम एक त्रुटि के साथ पूर्ण होता है, तो awaitAll() अपवाद फेंकता है।

suspend fun <T> loadAll(requests: List<suspend () -> T>): List<T> {
    return coroutineScope {
        val deferreds = requests.map { async { it() } }
        deferreds.awaitAll()
    }
}

async और launch में अंतर

async और launch के बीच चुनाव इस बात पर निर्भर करता है कि कोरूटिन का परिणाम आवश्यक है या नहीं। launch Job लौटाता है और fire-and-forget ऑपरेशनों के लिए उपयुक्त है, async Deferred लौटाता है और डेटा लौटाने वाले कार्यों के लिए उपयोग किया जाता है। सिंटैक्स और पैरामीटरों के संदर्भ में, बिल्डर समान हैं।

• launch → Job (कोई परिणाम नहीं), async → Deferred<T> (परिणाम T)
• launch — fire-and-forget कार्य (लॉ85गिंग, कैशिंग, एनलिटिक्स भेजना)
• async — समानांतर गणनाएँ (एकाधिक API से लोडिंग, बैच प्रसंस्करण)
• दोनों संरचित समवर्तनता और CoroutineStart पैरामीटर्स का समर्थन करते हैं
• await() केवल Deferred के लिए उपलब्ध है, launch परिणाम प्रदान नहीं करता

महत्वपूर्ण नियम: fire-and-forget के लिए async का उपयोग कभी न करें। यदि कोरूटिन का परिणाम आवश्यक नहीं है, तो launch का उपयोग करें। async Deferred बनाने का ओवरहेड बनाता है, जो ऐसे परिदृश्यों में उचित नहीं है।

मोबाइल डिवेलपमेंट में async के उदाहरण

Android में, async का उपयोग ViewModel और UseCases के अंदर समानांतर संचालनों के लिए किया जाता है। सामान्य परिदृश्य: एकसाथ प्रोफ़ाइल और न्यूज़ फ़ीड लोड करना, एकाधिक मौसम सेवाओं से मौसम प्राप्त करना, सर्वर के साथ बैच डेटा सिंक्रोनिजेशन।

class HomeViewModel : ViewModel() {
    fun loadHomeScreen() {
        viewModelScope.launch {
            val userData = async(Dispatchers.IO) { repository.getUserData() }
            val newsFeed = async(Dispatchers.IO) { repository.getNewsFeed() }
            val notifications = async(Dispatchers.IO) { repository.getNotifications() }

            val state = HomeState(
                user = userData.await(),
                news = newsFeed.await(),
                unread = notifications.await()
            )
            _uiState.update { state }
        }
    }
}

त्रुटि पृथक्करण के लिए async के एक समूह को coroutineScope या supervisorScope में लपेटने की अनुशंसा की जाती है। supervisorScope शेष async कोरूटिनों को जारी रखने की अनुमति देता है भले ही एक विफल हो जाए — गैर-महत्वपूर्ण संचालनों के लिए उपयोगी।