Coroutine Builder: यह क्या है, कोरूटीन बिल्डरों के प्रकार और वे कैसे काम करते हैं

Coroutine Builder क्या है?

Coroutine Builder एक Kotlin एक्सटेंशन फ़ंक्शन है जो CoroutineScope और एक suspend ब्लॉक लेता है, एक नया कोरूटीन बनाता और चलाता है। प्रत्येक बिल्डर परिभाषित करता है कि कोरूटीन कैसे निष्पादित होगा: परिणाम के साथ या बिना, थ्रेड ब्लॉकिंग के साथ या अतुल्यकालिक रूप से। बिल्डर भाषा के कोरूटीन मॉडल में प्रवेश बिंदु हैं।

सभी बिल्डर CoroutineScope के माध्यम से काम करते हैं, जो चाइल्ड कोरूटीन के जीवनचक्र का प्रबंधन करता है। जब कोई स्कोप रद्द किया जाता है, तो उसके माध्यम से चलाए गए सभी कोरूटीन स्वचालित रूप से रद्द हो जाते हैं — यह संरचित समवर्तीता का सिद्धांत है। यह दृष्टिकोण कोरूटीन लीक को रोकता है और पूर्वानुमानित समाप्ति सुनिश्चित करता है।

import kotlinx.coroutines.*

fun main() = runBlocking {
    // बिल्डर CoroutineScope के अंदर चलते हैं
    val job = launch {
        delay(1000L)
        println("विश्व!")
    }
    println("नमस्ते,")
    job.join()
}

कोरूटीन बिल्डरों के मुख्य प्रकार

Kotlin चार अंतर्निहित कोरूटीन बिल्डर प्रदान करता है: launch, async, runBlocking और produce। प्रत्येक का अपना रिटर्न प्रकार और अनुप्रयोग क्षेत्र होता है। Android मोबाइल डेवलपमेंट के लिए, मुख्य बिल्डर launch और async हैं — ये गैर-अवरोधक तरीके से काम करते हैं और आर्किटेक्चरल घटकों के साथ एकीकृत होते हैं।

प्रत्येक बिल्डर अतिरिक्त पैरामीटर स्वीकार करता है: CoroutineStart (लॉन्च रणनीति), CoroutineContext (डिस्पैचर, अपवाद) और एक नामित कोड ब्लॉक। डिफ़ॉल्ट रूप से, कोरूटीन तुरंत शुरू होता है (CoroutineStart.DEFAULT)।

launch: fire-and-forget निष्पादन

launch Android डेवलपमेंट में सबसे अधिक उपयोग किया जाने वाला बिल्डर है। यह एक कोरूटीन चलाता है जो परिणाम नहीं लौटाता, और अपने जीवनचक्र के प्रबंधन के लिए एक Job ऑब्जेक्ट लौटाता है। यह उन कार्यों के लिए आदर्श विकल्प है जिनमें केवल साइड इफ़ेक्ट की आवश्यकता होती है: डेटाबेस में सहेजना, एनालिटिक्स भेजना, UI अपडेट करना।

launch का सिंटैक्स और उपयोग

launch बिल्डर CoroutineScope, एक वैकल्पिक CoroutineContext और एक suspend ब्लॉक स्वीकार करता है। लौटाया गया Job कोरूटीन को रद्द करने, उसके पूरा होने की प्रतीक्षा करने या उसकी स्थिति जांचने की अनुमति देता है।

val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
val job: Job = scope.launch(CoroutineStart.LAZY) {
    val data = fetchFromNetwork()
    saveToDatabase(data)
}
job.start()
job.join()

CoroutineStart.LAZY पैरामीटर start() या join() के स्पष्ट कॉल तक निष्पादन को स्थगित करता है। यह विलंबित आरंभीकरण और सशर्त निष्पादन के लिए उपयोगी है। मानक तत्काल निष्पादन के लिए CoroutineStart.DEFAULT का उपयोग किया जाता है या पैरामीटर को छोड़ दिया जाता है।

async: परिणाम के साथ समानांतर गणना

async एक बिल्डर है जो Deferred<T> लौटाता है — परिणाम का एक अतुल्यकालिक वादा। await() को कॉल करना परिणाम प्राप्त होने तक कोरूटीन को स्थगित करता है, बिना थ्रेड को ब्लॉक किए। यह Kotlin कोरूटीन में समानांतर कार्यों के लिए प्राथमिक तंत्र है।

दो अनुरोधों को समानांतर में चलाना

async विशेष रूप से प्रभावी होता है जब आपको एक साथ कई स्वतंत्र संचालन निष्पादित करने की आवश्यकता होती है। suspend फ़ंक्शन के अनुक्रमिक कॉल के विपरीत, async कोरूटीन को समानांतर में चलाता है, कुल निष्पादन समय को कम करता है।

suspend fun fetchUserData(): UserData {
    val deferred1 = CoroutineScope(Dispatchers.IO).async { api.getProfile() }
    val deferred2 = CoroutineScope(Dispatchers.IO).async { api.getSettings() }
    val deferred3 = CoroutineScope(Dispatchers.IO).async { api.getNotifications() }
    return UserData(
        profile = deferred1.await(),
        settings = deferred2.await(),
        notifications = deferred3.await()
    )
}

Deferred Job से विरासत प्राप्त करता है, इसलिए async सभी जीवनचक्र संचालन का समर्थन करता है: रद्दीकरण, पूर्णता प्रतीक्षा, अपवाद हैंडलिंग। जब कोई स्कोप रद्द किया जाता है, तो चाइल्ड Deferred कोरूटीन स्वचालित रूप से रद्द हो जाते हैं।

runBlocking: blocking दुनिया का पुल

runBlocking एकमात्र बिल्डर है जो कोरूटीन के पूरा होने तक वर्तमान थ्रेड को ब्लॉक करता है। यह एक नया CoroutineScope बनाता है और पारित कोरूटीन को चलाता है, कॉल करने वाले थ्रेड को ब्लॉक करता है। इसका उपयोग main() प्रवेश बिंदुओं, परीक्षणों में, और blocking कोड के साथ एकीकरण करते समय किया जाता है।

runBlocking कब आवश्यक है

runBlocking तीन परिदृश्यों में उचित है: एप्लिकेशन प्रवेश बिंदु (main), suspend फ़ंक्शन के यूनिट परीक्षण, और कॉलबैक-आधारित लाइब्रेरी के साथ एकीकरण जहां suspend का उपयोग नहीं किया जा सकता। उत्पादन Android कोड में, मुख्य थ्रेड पर runBlocking का उपयोग दृढ़ता से अनुशंसित नहीं है।

class CoroutineTest {
    @Test
    fun `test suspend function`() = runBlocking {
        val result = mySuspendFunction()
        assertEquals("expected", result)
    }
}

परीक्षणों के लिए, runBlocking के बजाय kotlinx-coroutines-test का TestCoroutineDispatcher के साथ उपयोग करने की अनुशंसा की जाती है — यह समय नियंत्रण प्रदान करता है और परीक्षण वातावरण में ब्लॉकिंग से बचाता है।

सही बिल्डर कैसे चुनें

Coroutine Builder का चुनाव लौटाए गए परिणाम और निष्पादन परिदृश्य पर निर्भर करता है। यदि संचालन को डेटा लौटाने की आवश्यकता नहीं है — launch का उपयोग करें। यदि आपको अतुल्यकालिक संचालन के परिणाम की आवश्यकता है — async का उपयोग करें। runBlocking का उपयोग केवल ब्रिजिंग के लिए करें, और रिएक्टिव स्ट्रीम के लिए produce को Flow से बदलें।

Android के लिए व्यावहारिक अनुशंसाएँ

Kotlin Coroutines का उपयोग करने वाली Android परियोजनाओं में, बिल्डरों की मुख्य जोड़ी launch और async है। launch का उपयोग ViewModel और UseCases में कोरूटीन चलाने के लिए किया जाता है, जबकि async का उपयोग नेटवर्क या डेटाबेस पर समानांतर अनुरोधों के लिए किया जाता है। आधुनिक लाइब्रेरी (Ktor, Room) पहले से ही suspend फ़ंक्शन का समर्थन करती हैं, जो async के प्रत्यक्ष उपयोग की आवश्यकता को कम करता है।

• launch — fire-and-forget के लिए (लॉगिंग, एनालिटिक्स, कैशिंग)
• async — परिणामों के संयोजन के साथ समानांतर अनुरोधों के लिए
• runBlocking — केवल main() और परीक्षणों में (उत्पादन में Main थ्रेड पर नहीं)
• produce — Flow / SharedFlow / StateFlow से बदलें