Kotlin में समवर्तीता और मल्टीथ्रेडिंग: उन्नत स्तर

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

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

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

Kotlin में समवर्तीता और मल्टीथ्रेडिंग: उन्नत स्तर

आधुनिक विकास में, समवर्तीता का कुशल प्रबंधन तेज़ और उत्तरदायी एप्लिकेशन बनाने की कुंजी है। Kotlin, कोरूटीन (coroutines) के अंतर्निहित समर्थन के कारण, मानक Java थ्रेड्स से कहीं आगे जाकर एक शक्तिशाली और लचीला टूलकिट प्रदान करता है। इस लेख में, हम Kotlin में समवर्तीता और मल्टीथ्रेडिंग की उन्नत अवधारणाओं पर चर्चा करेंगे, जिसमें Channel, Flow, Mutex के साथ काम करना और शेड्यूलर की बारीकियाँ शामिल हैं।

1. कोरूटीन: मूल बातों से गहरा

कोरूटीन हल्के-फुल्के थ्रेड हैं जो आपको अनिवार्य शैली में अतुल्यकालिक कोड लिखने की अनुमति देते हैं। हालाँकि, उन्नत स्तर पर यह समझना महत्वपूर्ण है कि डिस्पैचर (Dispatchers) और कोरूटीन संदर्भ कैसे काम करते हैं।

शेड्यूलर (Dispatchers)

प्रदर्शन के लिए सही डिस्पैचर का चयन महत्वपूर्ण है:

Dispatchers.Default — CPU-गहन कार्यों के लिए (डिफ़ॉल्ट रूप से प्रोसेसर कोर की संख्या के बराबर थ्रेड पूल का उपयोग करता है)।
Dispatchers.IO — इनपुट-आउटपुट संचालन (नेटवर्क, फ़ाइलें) के लिए। थ्रेड पूल कॉन्फ़िगरेशन के आधार पर 64 थ्रेड्स (या अधिक) तक विस्तारित हो सकता है।
Dispatchers.Main — UI थ्रेड (Android, JavaFX) के लिए।
newSingleThreadContext और newFixedThreadPoolContext — अपने स्वयं के पूल बनाने के लिए।

import kotlinx.coroutines.*

fun main() = runBlocking {    launch(Dispatchers.Default) {        println("CPU-bound task on ${Thread.currentThread().name}")    }    launch(Dispatchers.IO) {        println("IO-bound task on ${Thread.currentThread().name}")    }}

संरचित समवर्तीता

Kotlin की प्रमुख विशेषताओं में से एक संरचित समवर्तीता है। यह सुनिश्चित करता है कि मूल कोरूटीन के पूरा होने से पहले चाइल्ड कोरूटीन पूरे हो जाएँ। यह मेमोरी लीक को रोकता है और जीवनचक्र प्रबंधन को सरल बनाता है।

fun main() = runBlocking {    coroutineScope {        launch {            delay(1000)            println("Task 1 completed")        }        launch {            delay(500)            println("Task 2 completed")        }    }    println("All tasks completed")}

2. कोरूटीन के बीच डेटा स्थानांतरित करने के लिए चैनल (Channel)

Channel कोरूटीन के लिए ब्लॉकिंग कतार (BlockingQueue) का एक एनालॉग है। यह कोरूटीन के बीच सुरक्षित रूप से डेटा स्थानांतरित करने की अनुमति देता है, यदि चैनल भरा है तो भेजने वाले को या यदि चैनल खाली है तो प्राप्त करने वाले को रोक देता है।

चैनलों के प्रकार

RendezvousChannel (डिफ़ॉल्ट) — कोई बफ़र नहीं है। प्राप्त होने तक भेजना अवरुद्ध रहता है।
BufferedChannel — निर्दिष्ट आकार का बफ़र होता है।
ConflatedChannel — केवल अंतिम भेजे गए मान को संग्रहीत करता है, पिछले मानों को अधिलेखित करता है।
UnlimitedChannel — असीमित बफ़र (सावधान: OOM का कारण बन सकता है)।

import kotlinx.coroutines.*import kotlinx.coroutines.channels.*

fun main() = runBlocking {    val channel = Channel<Int>(capacity = 5) // Buffered channel

    launch {        for (i in 1..10) {            channel.send(i)            println("Sent: $i")        }        channel.close()    }

    launch {        for (value in channel) {            println("Received: $value")            delay(100)        }    }}