Kotlin कार्य अनुसूचक: अवलोकन और उदाहरण

Kotlin कार्य अनुसूचक: पूर्ण अवलोकन और उपयोग उदाहरण

कार्य अनुसूचक किसी भी एप्लिकेशन का एक महत्वपूर्ण घटक है, जो कोड को शेड्यूल पर, विलंब के साथ या आवधिक रूप से निष्पादित करने की अनुमति देता है। Kotlin भाषा में, विशेष रूप से JVM, Android या मल्टीप्लेटफ़ॉर्म प्रोजेक्ट्स पर विकास करते समय, अनुसूचकों को लागू करने के कई तरीके हैं। इस लेख में, हम मुख्य उपकरणों की विस्तार से जाँच करेंगे: kotlinx-coroutines-core की अंतर्निहित क्षमताएँ, java.util.Timer, java.util.concurrent.Executors, और गेम और एनिमेशन के लिए विशेष लाइब्रेरी korGE।

1. कोरूटीन-आधारित कार्य अनुसूचक (kotlinx-coroutines-core)

यह Kotlin एप्लिकेशन के लिए सबसे आधुनिक और अनुशंसित तरीका है। kotlinx-coroutines-core लाइब्रेरी विलंबित और आवधिक कोड निष्पादन के लिए लचीले साधन प्रदान करती है।

स्थापना

build.gradle.kts में निर्भरता जोड़ें:

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

विलंबित कार्य (delay)

कोरूटीन के अंदर delay का उपयोग करके सरल विलंब निष्पादन:

import kotlinx.coroutines.*

fun main() = runBlocking {    println("प्रारंभ: ${System.currentTimeMillis()}")    delay(2000) // 2 सेकंड का विलंब    println("2 सेकंड बाद निष्पादित: ${System.currentTimeMillis()}")}

launch और while के माध्यम से आवधिक कार्य

import kotlinx.coroutines.*

fun main() = runBlocking {    val job = launch {        repeat(5) { i ->            println("कार्य #${i + 1}: ${System.currentTimeMillis()}")            delay(1000)        }    }    job.join()}

पृष्ठभूमि थ्रेड के लिए Dispatchers का उपयोग

अनुसूचक विभिन्न डिस्पैचर्स पर काम कर सकता है, उदाहरण के लिए नेटवर्क संचालन के लिए Dispatchers.IO:

import kotlinx.coroutines.*

fun main() = runBlocking {    val job = launch(Dispatchers.IO) {        println("थ्रेड में निष्पादित: ${Thread.currentThread().name}")        delay(3000)        println("पूर्ण हुआ")    }    job.join()}

2. क्लासिक अनुसूचक: java.util.Timer

यदि आप JVM वातावरण में काम कर रहे हैं और पारंपरिक दृष्टिकोण का उपयोग करना चाहते हैं, तो Timer और TimerTask सरल परिदृश्यों के लिए उपयुक्त हैं।

import java.util.*

fun main() {    val timer = Timer()    val task = object : TimerTask() {        override fun run() {            println("आवधिक कार्य: ${System.currentTimeMillis()}")        }    }    // कार्य को 1 सेकंड बाद शुरू करें, फिर हर 2 सेकंड में    timer.schedule(task, 1000, 2000)

    // 10 सेकंड बाद रोकें    Thread.sleep(10000)    timer.cancel()}

एक बार का विलंबित कार्य

val timer = Timer()timer.schedule(object : TimerTask() {    override fun run() {        println("3 सेकंड बाद एक बार का कार्य")    }}, 3000)

3. Executors के साथ अनुसूचक (ScheduledExecutorService)

Java Concurrency से अधिक शक्तिशाली और लचीला उपकरण, जो Kotlin के साथ अच्छी तरह से एकीकृत होता है।

import java.util.concurrent.*

fun main() {    val scheduler = Executors.newScheduledThreadPool(2)

    // विलंब के साथ कार्य    scheduler.schedule({        println("विलंबित कार्य: ${System.currentTimeMillis()}")    }, 2, TimeUnit.SECONDS)

    // निश्चित विलंब के साथ आवधिक कार्य    val periodicTask = scheduler.scheduleWithFixedDelay({        println("आवधिक कार्य: ${System.currentTimeMillis()}")    }, 1, 3, TimeUnit.SECONDS)

    // 15 सेकंड बाद रोकें    Thread.sleep(15000)    periodicTask.cancel(false)    scheduler.shutdown()}