launch — सार, fire-and-forget कोरूटीन लॉन्च और यह कैसे काम करता है

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

launch एक Kotlin एक्सटेंशन फ़ंक्शन है, जो kotlinx.coroutines आयात के माध्यम से उपलब्ध है, जो दिए गए CoroutineScope में एक नया कोरूटीन बनाता है। सामान्य फ़ंक्शनों के विपरीत, launch के अंदर का कोड समवर्ती रूप से निष्पादित होता है — कोरूटीन बिना थ्रेड को ब्लॉक किए रुक (suspend) सकता है और बाद में फिर से शुरू हो सकता है।

launch बिल्डर Kotlin कोरूटीन मॉडल का मूलभूत निर्माण खंड है। यह गणना किया गया मान नहीं लौटाता बल्कि एक Job ऑब्जेक्ट लौटाता है जो कोरूटीन निष्पादन को नियंत्रित करने की अनुमति देता है। किसी अन्य कोरूटीन के अंदर launch के माध्यम से शुरू किए गए सभी चाइल्ड कोरूटीन पैरेंट से बंधे होते हैं।

launch का सिंटैक्स और पैरामीटर

launch बिल्डर को कई पैरामीटरों के साथ एक inline फ़ंक्शन के रूप में परिभाषित किया गया है: CoroutineScope, CoroutineContext, CoroutineStart और एक suspend ब्लॉक। पैरामीटरों के डिफ़ॉल्ट मान हैं, जो launch को सामान्य परिदृश्यों के लिए सुविधाजनक बनाते हैं।

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job

context पैरामीटर एक CoroutineContext स्वीकार करता है जो डिस्पैचर, अपवाद हैंडलर और नामित तत्व को जोड़ता है। अक्सर Dispatchers.IO, Dispatchers.Main या SupervisorJob त्रुटि पृथक्करण के लिए पारित किया जाता है।

Job और जीवनचक्र प्रबंधन

Job — लौटाया गया ऑब्जेक्ट जो कोरूटीन के जीवनचक्र का प्रतिनिधित्व करता है। Job अवस्थाओं में हो सकता है: New, Active, Completing, Completed, Cancelling, Cancelled। प्रत्येक अवस्था निष्पादन स्थिति को दर्शाती है और परिवर्तनों पर प्रतिक्रिया करने की अनुमति देती है।

val job = CoroutineScope(Dispatchers.IO).launch {
    repeat(10) { i ->
        delay(1000L)
        println("प्रगति: $i")
    }
}

println("जॉब सक्रिय है: ${job.isActive}")
delay(2500L)
job.cancel()
println("जॉब रद्द है: ${job.isCancelled}")

Job एक पदानुक्रम का समर्थन करता है: यदि पैरेंट कोरूटीन रद्द किया जाता है, तो सभी चाइल्ड स्वचालित रूप से रद्द हो जाते हैं। SupervisorJob इस व्यवहार को बदलता है — चाइल्ड कोरूटीन किसी एक के विफल होने पर रद्द नहीं होते।

launch में संरचित सहसमवर्तीता

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

नेस्टेड launch कॉल

नेस्टेड launch कॉल के साथ, कोरूटीन का एक पेड़ बनता है। पैरेंट कोरूटीन सभी चाइल्ड के पूरा होने की प्रतीक्षा करता है, जिससे पूर्वानुमानित निष्पादन क्रम सुनिश्चित होता है और संसाधन प्रबंधन सरल होता है।

fun main() = runBlocking {
    launch {
        launch {
            delay(1000L)
            println("चाइल्ड 1 पूर्ण")
        }
        launch {
            delay(500L)
            println("चाइल्ड 2 पूर्ण")
        }
        println("सभी चाइल्ड इस पंक्ति से पहले पूर्ण होते हैं")
    }
}

यह व्यवहार थ्रेड-आधारित सहसमवर्तीता से भिन्न है, जहाँ चाइल्ड थ्रेड पैरेंट से बंधे नहीं होते। कोरूटीन में, पैरेंट तब तक पूरा नहीं होता जब तक सभी चाइल्ड अपना काम पूरा नहीं कर लेते।

launch में अपवाद प्रबंधन

launch में अपवाद प्रबंधन Job के प्रकार पर निर्भर करता है। सामान्य Job के लिए, अपवाद पैरेंट कोरूटीन में प्रसारित होते हैं और उसे रद्द कर देते हैं। SupervisorJob या SupervisorScope के लिए, अपवाद पृथक होते हैं — एक चाइल्ड कोरूटीन में त्रुटि दूसरों को प्रभावित नहीं करती।

val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
scope.launch {
    try {
        riskyOperation()
    } catch (e: Exception) {
        println("पकड़ा गया: ${e.message}")
    }
}
scope.launch {
    println("यह अभी भी SupervisorJob की बदौलत चलता है")
}

अनकैच अपवादों के वैश्विक प्रबंधन के लिए, CoroutineExceptionHandler का उपयोग किया जाता है। यह उन अपवादों को पकड़ता है जिन्हें कोरूटीन के अंदर संभाला नहीं गया था और एप्लिकेशन को क्रैश किए बिना त्रुटि लॉग करने की अनुमति देता है।

Android में launch के उपयोग उदाहरण

Android में, launch का उपयोग हर जगह किया जाता है: ViewModel से WorkManager तक। मुख्य पैटर्न घटक जीवनचक्र समाप्त होने पर स्वचालित कोरूटीन रद्दीकरण के लिए Fragment में lifecycleScope और ViewModel में viewModelScope का उपयोग है।

class ProfileViewModel : ViewModel() {
    private val repository = UserRepository()

    fun loadProfile(userId: String) {
        viewModelScope.launch(Dispatchers.IO) {
            val profile = repository.fetchProfile(userId)
            withContext(Dispatchers.Main) {
                _profileState.update { it.copy(profile = profile) }
            }
        }
    }
}

viewModelScope ViewModel के नष्ट होने पर स्वचालित रूप से कोरूटीन रद्द कर देता है। यह मेमोरी लीक को समाप्त करता है और सुनिश्चित करता है कि संदर्भ खोने के बाद बैकग्राउंड संचालन जारी न रहे। अतिरिक्त रूप से, डिस्पैचर के बीच स्विच करने के लिए withContext का उपयोग किया जा सकता है।