Kotlin में समवर्तीता और मल्टीथ्रेडिंग: एक संपूर्ण गाइड

Kotlin में समवर्तीता और मल्टीथ्रेडिंग का परिचय

आधुनिक एप्लिकेशनों को अक्सर एक साथ कई कार्य करने की आवश्यकता होती है - नेटवर्क अनुरोधों को संसाधित करने से लेकर डेटाबेस के साथ काम करने तक। Kotlin भाषा में, जिसका उपयोग Android, सर्वर एप्लिकेशन (Ktor, Spring) और यहां तक कि डेस्कटॉप समाधानों के विकास के लिए सक्रिय रूप से किया जाता है, समवर्तीता और मल्टीथ्रेडिंग के लिए शक्तिशाली उपकरण लागू किए गए हैं।

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

1. Kotlin में पारंपरिक थ्रेड (Threads)

Kotlin Java के साथ पूरी तरह से संगत है, इसलिए आप मानक क्लास Thread और Runnable का उपयोग कर सकते हैं। हालांकि, Kotlin सिंटैक्टिक शुगर जोड़ता है, जो कोड को अधिक संक्षिप्त बनाता है।

थ्रेड बनाना और चलाना

थ्रेड बनाने का मूल तरीका Thread कंस्ट्रक्टर में लैम्ब्डा पास करना है:

fun main() {    val thread = Thread {        println("थ्रेड शुरू: ${Thread.currentThread().name}")        for (i in 1..5) {            println("गिनती: $i")            Thread.sleep(500)        }    }    thread.start()    println("मुख्य थ्रेड काम करता रहता है")    thread.join() // थ्रेड के समाप्त होने की प्रतीक्षा करें    println("मुख्य थ्रेड समाप्त")}

इस उदाहरण में, हमने एक थ्रेड बनाया है जो 500 ms के विलंब के साथ 1 से 5 तक संख्याएँ प्रिंट करता है। विधि join() मुख्य थ्रेड को चाइल्ड थ्रेड के समाप्त होने तक प्रतीक्षा करने के लिए बाध्य करती है।

थ्रेड की समस्याएँ

• उच्च संसाधन खपत - प्रत्येक थ्रेड को अलग मेमोरी स्टैक (आमतौर पर 1 MB) की आवश्यकता होती है।
• सिंक्रोनाइज़ेशन की जटिलता - साझा डेटा के साथ काम करते समय रेस कंडीशन (race condition) होना आसान है।
• सीमित संख्या - एक डिवाइस पर प्रदर्शन खोए बिना हजारों थ्रेड नहीं चलाए जा सकते।

यही कारण है कि Kotlin में कोरूटीन दिखाई दिए - एक हल्का विकल्प।

2. कोरूटीन (Coroutines) - Kotlin में आधुनिक समवर्तीता

कोरूटीन हल्के थ्रेड हैं जो सिस्टम थ्रेड को ब्लॉक किए बिना अपने निष्पादन को रोक सकते हैं। वे Kotlin में एसिंक्रोनस प्रोग्रामिंग के लिए मुख्य उपकरण हैं।

कोरूटीन को जोड़ना

कोरूटीन के साथ काम करने के लिए, build.gradle.kts में निर्भरता जोड़ना आवश्यक है:

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

कोरूटीन का मूल उदाहरण

import kotlinx.coroutines.*

fun main() = runBlocking {    println("थ्रेड में काम शुरू: ${Thread.currentThread().name}")

    launch { // नया कोरूटीन शुरू करें        delay(1000) // नॉन-ब्लॉकिंग विलंब        println("कोरूटीन: ${Thread.currentThread().name}")    }

    println("मुख्य कोरूटीन काम करता रहता है")    delay(2000) // चाइल्ड कोरूटीन के समाप्त होने की प्रतीक्षा करें    println("अंत")}

मुख्य बिंदु:

• runBlocking - सामान्य कोड और कोरूटीन के बीच पुल (वर्तमान थ्रेड को ब्लॉक करता है)।
• launch - एक कोरूटीन शुरू करता है जो परिणाम नहीं लौटाता।
• delay - नॉन-ब्लॉकिंग विलंब, Thread.sleep() के विपरीत।

परिणाम प्राप्त करने के लिए Async और await

यदि कोरूटीन को मान लौटाना है, तो async का उपयोग करें:

fun main() = runBlocking {    val deferred1 = async {        delay(1000)        "परिणाम 1"    }    val deferred2 = async {        delay(500)        "परिणाम 2"    }

    println("परिणामों की प्रतीक्षा...")    val result1 = deferred1.await()    val result2