Kotlin में समवर्तीता और मल्टीथ्रेडिंग: कोरूटीन, थ्रेड और व्यावहारिक उदाहरण

शुरुआती लोगों के लिए ऑनलाइन Python प्रशिक्षक

Python आसानी से सीखें बिना सिद्धांत के बोझ के। स्वचालित जांच के साथ व्यावहारिक कार्य हल करें और ब्राउज़र में सीधे कोड लिखें।

पाठ्यक्रम शुरू करें

```html

Kotlin में समवर्तीता और मल्टीथ्रेडिंग: सिद्धांत से व्यवहार तक

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

1. Kotlin में थ्रेड्स (Threads): क्लासिकल दृष्टिकोण

थ्रेड्स समानांतर निष्पादन का एक बुनियादी तंत्र है, जो Java से विरासत में मिला है। Kotlin में, आप Java की तरह ही थ्रेड बना सकते हैं, लेकिन अधिक संक्षिप्त सिंटैक्स के साथ।

थ्रेड शुरू करने का एक सरल उदाहरण:

fun main() {    thread {        println("थ्रेड शुरू: ${Thread.currentThread().name}")        Thread.sleep(1000)        println("थ्रेड समाप्त")    }    println("मुख्य थ्रेड: ${Thread.currentThread().name}")    Thread.sleep(2000)}

हालाँकि, थ्रेड्स की कमियाँ हैं: वे भारी होते हैं (प्रत्येक थ्रेड लगभग 1 MB मेमोरी की खपत करता है), उनकी संख्या सीमित होती है, और कॉन्टेक्स्ट स्विचिंग महंगी होती है। हज़ारों समानांतर कार्यों वाले आधुनिक अनुप्रयोगों के लिए, थ्रेड्स सबसे अच्छा विकल्प नहीं हैं। यहीं पर कोरूटीन मददगार साबित होते हैं।

2. कोरूटीन (Coroutines): हल्का विकल्प

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

शुरू करने के लिए, build.gradle.kts में डिपेंडेंसी जोड़ें:

dependencies {    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0")}

एक सरल कोरूटीन का उदाहरण:

import kotlinx.coroutines.*

fun main() = runBlocking {    launch {        delay(1000L) // नॉन-ब्लॉकिंग विलंब        println("कोरूटीन से नमस्ते!")    }    println("मुख्य कोरूटीन से नमस्ते")    delay(2000L)}

यहाँ launch एक नया कोरूटीन शुरू करता है, और delay इसे थ्रेड को ब्लॉक किए बिना रोकता है। runBlocking का उपयोग सभी कोरूटीन के पूरा होने तक मुख्य थ्रेड को ब्लॉक करने के लिए किया जाता है (आमतौर पर केवल main और टेस्ट में उपयोग किया जाता है)।

2.1. Suspend-फ़ंक्शन

suspend कीवर्ड फ़ंक्शन के निष्पादन को थ्रेड को ब्लॉक किए बिना रोकने की अनुमति देता है। यह Kotlin में एसिंक्रोनस प्रोग्रामिंग का आधार है।

suspend fun fetchUser(): String {    delay(500L) // नेटवर्क अनुरोध का अनुकरण    return "User123"}

fun main() = runBlocking {    val user = fetchUser()    println("उपयोगकर्ता प्राप्त: $user")}

2.2. समानांतर कार्यों के लिए Async और Deferred

यदि आपको कई कार्यों को समानांतर में निष्पादित करना है और उनके परिणामों की प्रतीक्षा करनी है, तो async और Deferred का उपयोग करें:

fun main() = runBlocking {    val time = measureTimeMillis {        val user = async { fetchUser() }        val profile = async { fetchProfile() }        println("परिणाम: ${user.await()}, ${profile.await()}")    }    println("निष्पादन समय: $time ms")}

suspend fun fetchUser(): String {    delay(500)    return "User"}

suspend fun fetchProfile(): String {    delay(500)    return "Profile"}

दोनों कार्य समानांतर में निष्पादित होते हैं, जिससे कुल समय कम हो जाता है।