Kotlin कार्य शेड्यूलर: kotlinx.coroutines और पृष्ठभूमि कार्यों के लिए लाइब्रेरीज़

Kotlin पर कार्य शेड्यूलर: कोरूटीन से लेकर कॉर्पोरेट समाधान तक

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

हम तीन मुख्य दृष्टिकोणों पर विचार करेंगे:

• Kotlin Coroutines के अंतर्निहित साधन (हल्के थ्रेड)
• Android के लिए WorkManager लाइब्रेरी
• Kotlin रैपर के साथ क्लासिक Quartz Scheduler

1. kotlinx.coroutines पर आधारित शेड्यूलर

kotlinx.coroutines Kotlin में एसिंक्रोनस प्रोग्रामिंग के लिए मानक लाइब्रेरी है। यह विलंबित और आवधिक कार्यों को बनाने के लिए शक्तिशाली उपकरण प्रदान करती है।

मुख्य घटक:

• delay() — कोरूटीन के निष्पादन में विलंब
• launch और async — कोरूटीन प्रारंभ करना
• CoroutineScope — जीवनचक्र प्रबंधन
• Dispatchers — निष्पादन थ्रेड का चयन

हर 5 सेकंड में दोहराव वाले सरल कार्य शेड्यूलर का उदाहरण:

import kotlinx.coroutines.*

fun main() = runBlocking {    val job = launch {        repeat(10) { i ->            println("कार्य #$i ${System.currentTimeMillis()} पर निष्पादित हुआ")            delay(5000) // 5 सेकंड का विराम        }    }    job.join()    println("शेड्यूलर ने कार्य समाप्त कर दिया")}

अधिक जटिल परिदृश्यों (कार्य रद्द करना, त्रुटि प्रबंधन, आवृत्ति सीमा) के लिए Job और SupervisorJob का उपयोग करें:

val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())

fun schedulePeriodicTask(intervalMs: Long, action: suspend () -> Unit): Job {    return scope.launch {        while (isActive) {            try {                action()            } catch (e: Exception) {                println("त्रुटि: ${e.message}")            }            delay(intervalMs)        }    }}

// उपयोगval task = schedulePeriodicTask(2000) {    println("पृष्ठभूमि कार्य निष्पादित हो रहा है...")}

// 10 सेकंड के बाद रद्द करेंscope.launch {    delay(10000)    task.cancel()    println("कार्य रद्द कर दिया गया")}

लाभ: हल्कापन, अंतर्निहित रद्दीकरण समर्थन, Kotlin पारिस्थितिकी तंत्र के साथ एकीकरण। नुकसान: Android एप्लिकेशन के लिए उपयुक्त नहीं है जिन्हें सिस्टम रीस्टार्ट को सहन करना होता है।

2. Android के लिए WorkManager (Kotlin)

WorkManager Google की एक लाइब्रेरी है जो Android में एप्लिकेशन बंद होने या डिवाइस रीबूट होने के बाद भी विलंबित और पृष्ठभूमि कार्यों को निष्पादित करने के लिए है। यह कोरूटीन के ऊपर काम करती है।

मुख्य चरण:

1. CoroutineWorker से विरासत प्राप्त करने वाला एक वर्ग बनाएँ
2. doWork() विधि को लागू करें
3. WorkRequest (एक बार या आवधिक) कॉन्फ़िगर करें
4. WorkManager के माध्यम से कार्य को कतार में रखें

आवधिक कार्य का उदाहरण:

class MyPeriodicWorker(context: Context, params: WorkerParameters) :     CoroutineWorker(context, params) {

    override suspend fun doWork(): Result {        return try {            // आपका कार्य: सिंक्रनाइज़ेशन, सफाई आदि।            println("आवधिक कार्य ${System.currentTimeMillis()} पर निष्पादित हुआ")            Result.success()        } catch (e: Exception) {            Result.retry()        }    }}

// कॉन्फ़िगरेशन और प्रारंभval constraints = Constraints.Builder()    .setRequiredNetworkType(NetworkType.CONNECTED)    .build()

val periodicRequest = PeriodicWorkRequestBuilder&