Kotlin Coroutines: तरीके, उदाहरण, सेटअप

Coroutines क्या हैं और इनकी ज़रूरत क्यों है?

Coroutines (सह-प्रक्रियाएं) Kotlin में एसिंक्रोनस प्रोग्रामिंग के लिए एक शक्तिशाली टूल है, जो आपको इम्पेरेटिव स्टाइल में नॉन-ब्लॉकिंग कोड लिखने की अनुमति देता है। पारंपरिक threads के विपरीत, coroutines हल्के होते हैं: आप एक ही thread पर बिना ज्यादा मेमोरी खपत के हजारों coroutines चला सकते हैं।

Coroutines का मुख्य काम एसिंक्रोनस ऑपरेशन्स को आसान बनाना है: नेटवर्क रिक्वेस्ट, डेटाबेस रीडिंग, फ़ाइल ऑपरेशन और अन्य कार्य जिनमें इंतज़ार करना पड़ता है। जटिल callbacks या रिएक्टिव स्ट्रीम का उपयोग करने के बजाय, आप एक सीक्वेंशियल कोड लिखते हैं जो इंतज़ार के दौरान रुक जाता है और ऑपरेशन पूरा होने पर फिर से शुरू हो जाता है।

Coroutines लाइब्रेरी Kotlin इकोसिस्टम का हिस्सा है और JetBrains द्वारा आधिकारिक रूप से समर्थित है। इसका व्यापक रूप से Android डेवलपमेंट, सर्वर एप्लिकेशन (Ktor, Spring WebFlux) और डेस्कटॉप एप्लिकेशन में उपयोग किया जाता है।

Coroutines की स्थापना (Setup)

चूंकि Coroutines pip या npm के माध्यम से स्थापित करने वाली कोई अलग लाइब्रेरी नहीं है, बल्कि Kotlin इकोसिस्टम का हिस्सा है, इसलिए इसका कनेक्शन आपके बिल्ड मैनेजर पर निर्भर करता है।

Gradle (Kotlin DSL)

dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
    // Android या Dispatchers.Main के उपयोग के लिए
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0")
}

Gradle (Groovy DSL)

dependencies {
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0'
}

Maven

<dependency>
    <groupId>org.jetbrains.kotlinx</groupId>
    <artifactId>kotlinx-coroutines-core</artifactId>
    <version>1.9.0</version>
</dependency>

त्वरित शुरुआत: पहला उदाहरण

चलिए एक सरल प्रोग्राम लिखते हैं जो एक coroutine शुरू करता है, रुकता है और एक संदेश प्रिंट करता है:

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("प्रोग्राम शुरू: ${Thread.currentThread().name}")
    
    launch {
        delay(1000L) // coroutine को 1 सेकंड के लिए रोकें (thread को ब्लॉक किए बिना)
        println("दुनिया! (coroutine से: ${Thread.currentThread().name})")
    }
    
    println("नमस्ते, (main से: ${Thread.currentThread().name})")
    delay(500L) // coroutine के पूरा होने का इंतज़ार करें
    println("प्रोग्राम समाप्त")
}

आउटपुट:

प्रोग्राम शुरू: main @coroutine#1
नमस्ते, (main से: @coroutine#1)
दुनिया! (coroutine से: @coroutine#2)
प्रोग्राम समाप्त

ध्यान दें: delay() thread को ब्लॉक नहीं करता, बल्कि केवल वर्तमान coroutine को रोकता है। main thread अन्य कार्यों के लिए स्वतंत्र रहता है।

Coroutines के मुख्य तरीके और फंक्शन

1. runBlocking

यह क्या करता है: एक नई coroutine शुरू करता है और उसके पूरा होने तक वर्तमान thread को ब्लॉक करता है। इसका उपयोग सामान्य सिंक्रोनस कोड और coroutines की दुनिया के बीच एक पुल के रूप में किया जाता है (आमतौर पर main फंक्शन या टेस्ट में)।

पैरामीटर:

context: CoroutineContext — coroutine का संदर्भ (डिफ़ॉल्ट EmptyCoroutineContext)
block: suspend CoroutineScope.() -> T — suspend ब्लॉक जो निष्पादित होगा

उदाहरण:

fun main() {
    val result = runBlocking {
        delay(1000L)
        "हो गया!"
    }
    println(result) // आउटपुट: हो गया!
}

2. launch

यह क्या करता है: एक नई coroutine शुरू करता है जो कोई परिणाम नहीं लौटाती (fire-and-forget के समान)। यह एक Job ऑब्जेक्ट लौटाता है जिसका उपयोग रद्द करने या प्रतीक्षा करने के लिए किया जा सकता है।

पैरामीटर: