Kotlin में कार्य कतारें: Coroutines, Flow और पृष्ठभूमि प्रसंस्करण के लिए लाइब्रेरीज़

Kotlin के लिए कार्य कतारें: कुशल पृष्ठभूमि प्रसंस्करण

Kotlin (विशेषकर Android, Ktor या Spring पर बैकएंड) में आधुनिक विकास में, मुख्य थ्रेड को अवरुद्ध किए बिना पृष्ठभूमि में कार्यों को निष्पादित करने की व्यवस्था करना अक्सर आवश्यक होता है। इसके लिए कार्य कतारों का उपयोग किया जाता है - ऐसे तंत्र जो संचालन को कतार में रखने और उन्हें क्रमिक या समवर्ती रूप से निष्पादित करने की अनुमति देते हैं। Kotlin में कोरूटीन (coroutines) का अंतर्निहित समर्थन इसके लिए शक्तिशाली उपकरण प्रदान करता है: Channel, Flow और डिस्पैचर। इसके अलावा, Kjob और Kotlinx-coroutines जैसी विशेष लाइब्रेरीज़ हैं जो कार्य प्रबंधन को सरल बनाती हैं।

इस लेख में, हम Kotlin पर कार्य कतारें बनाने के मुख्य दृष्टिकोणों, उनके लाभों का विश्लेषण करेंगे और व्यावहारिक कोड उदाहरण प्रदान करेंगे।

1. Kotlin के अंतर्निहित साधन: Channel और Flow

Channel कोरूटीन के बीच डेटा स्थानांतरित करने के लिए एक आदिम है, जो 'उत्पादक-उपभोक्ता' सिद्धांत पर काम करता है। यह एक सरल कार्य कतार बनाने के लिए आदर्श है।

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

suspend fun main() = coroutineScope {    val channel = Channel<String>(capacity = 10) // बफ़र किया गया चैनल

    // उत्पादक (कार्य प्रस्तुतकर्ता)    launch {        for (i in 1..5) {            val task = "कार्य संख्या $i"            println("प्रस्तुत: $task")            channel.send(task)            delay(100)        }        channel.close() // सभी कार्य भेजने के बाद चैनल बंद करें    }

    // उपभोक्ता (प्रसंस्करणकर्ता)    launch {        for (task in channel) { // जब तक चैनल खुला है स्वचालित रूप से प्राप्त करें            println("प्रसंस्करण हो रहा है: $task")            delay(300) // कार्य का अनुकरण        }        println("सभी कार्य संसाधित हो गए")    }}

Flow एक कोल्ड एसिंक्रोनस डेटा स्ट्रीम है जिसका उपयोग रद्दीकरण और रूपांतरण की क्षमता वाली कतार बनाने के लिए किया जा सकता है।

import kotlinx.coroutines.*import kotlinx.coroutines.flow.*

fun taskQueue(): Flow<String> = flow {    for (i in 1..5) {        emit("कार्य संख्या $i")        delay(200)    }}

suspend fun main() = coroutineScope {    taskQueue()        .map { task ->            "संसाधित: $task"        }        .collect { result ->            println(result)        }}

2. Kotlinx-coroutines: Dispatchers और Job

kotlinx-coroutines लाइब्रेरी (Kotlin के आधिकारिक पैकेज का हिस्सा) थ्रेड पूल में कार्यों को निष्पादित करने के लिए डिस्पैचर (Dispatchers.Default, Dispatchers.IO) प्रदान करती है। Job और SupervisorJob की सहायता से कतार के जीवनचक्र को प्रबंधित किया जा सकता है।

import kotlinx.coroutines.*

suspend fun main() = coroutineScope {    val job = SupervisorJob()    val scope = CoroutineScope(Dispatchers.IO + job)

    // कतार में कार्य जोड़ें    scope.launch {        repeat(10) { i ->            delay(100)            println("कार्य $i ${Thread.currentThread().name} में निष्पादित हो रहा है")        }    }

    // पूर्ण होने की प्रतीक्षा करें    delay(2000)    println("मुख्य थ्रेड कार्य जारी रखता है")}

अधिक जटिल परिदृश्यों (जैसे, पुनः प्रयास, कार्यों के बीच विलंब) के लिए retry या withTimeout फ़ंक्शन के साथ kotlinx-coroutines-core का उपयोग किया जा सकता है।

3. विशेष लाइब्रेरी: Kjob

Kjob Kotlin में पृष्ठभूमि कार्यों के प्रबंधन के लिए एक हल्की लाइब्रेरी है, जो कतारों, विलंबों, पुनः प्रयासों और निगरानी का समर्थन करती है। यह कोरूटीन के ऊपर काम करती है और बाहरी निर्भरता की आवश्यकता नहीं होती है।

Gradle के माध्यम से स्थापना:

implementation("io.github.oshai:kjob:2.2.0")

उपयोग का उदाहरण:

import io.