Kotlin में फंक्शन को देरी से कैसे कॉल करें?

परिचय

Kotlin जेवीएम पर चलता है, इसलिए जावा के `Timer` और `TimerTask` का उपयोग कर सकते हैं। साथ ही कोटलिन कोरआउट्स आधुनिक तरीका प्रदान करते हैं।

विधि 1: java.util.Timer (पारंपरिक)

import java.util.Timer
import java.util.TimerTask

fun main() {
    println("शुरुआत")
    
    Timer().schedule(5000) {  // 5 सेकंड देरी
        delayedFunction()
    }
    
    println("मुख्य थ्रेड जारी...")
    Thread.sleep(6000)  // मेन थ्रेड जीवित रखने के लिए
}

fun delayedFunction() {
    println("विलंबित फंक्शन कॉल!")
}

आउटपुट

शुरुआत
मुख्य थ्रेड जारी...
विलंबित फंक्शन कॉल!

विधि 2: Kotlin Coroutines (आधुनिक, अनुशंसित)

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("शुरुआत")
    
    // 5 सेकंड देरी
    launch {
        delay(5000L)
        delayedFunction()
    }
    
    println("मुख्य कोरआउट जारी...")
    // runBlocking स्वचालित रूप से प्रतीक्षा करता है
}

fun delayedFunction() {
    println("विलंबित फंक्शन कॉल (कोरआउट्स)!")
}

विधि 3: Handler (एंड्रॉइड मेन थ्रेड के लिए)

import android.os.Handler
import android.os.Looper

// एंड्रॉइड एक्टिविटी/फ्रैगमेंट में
fun delayOnMainThread() {
    Handler(Looper.getMainLooper()).postDelayed({
        delayedFunction()
    }, 5000)
}

विधि 4: Thread.sleep (ब्लॉकिंग - सावधानी से उपयोग करें)

fun main() {
    println("शुरुआत")
    Thread.sleep(5000)  // वर्तमान थ्रेड ब्लॉक करता है
    delayedFunction()
    println("समाप्त")
}

विधि 5: पुनरावृत्ति टाइमर (Periodic)

import java.util.Timer

fun main() {
    val timer = Timer()
    
    // हर 2 सेकंड में चलाएं
    timer.scheduleAtFixedRate(0, 2000) {
        println("पुनरावृत्ति कार्य: ${System.currentTimeMillis()}")
    }
    
    Thread.sleep(10000)
    timer.cancel()
    println("टाइमर रद्द किया गया")
}

कोरआउट्स में उन्नत पैटर्न

रद्द करने योग्य देरी:

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        try {
            delay(5000L)
            println("पूरा हुआ")
        } catch (e: CancellationException) {
            println("रद्द कर दिया गया!")
            throw e
        }
    }
    
    delay(2000)
    job.cancel()  // 2 सेकंड बाद रद्द करें
    job.join()
}

परिणाम के साथ देरी:

import kotlinx.coroutines.*

suspend fun fetchDataDelayed(): String {
    delay(3000L)
    return "डेटा लोड हुआ"
}

fun main() = runBlocking {
    val deferred = async { fetchDataDelayed() }
    println("प्रतीक्षा中...")
    val result = deferred.await()
    println("परिणाम: $result")
}

सारांश: कब क्या उपयोग करें?

निष्कर्ष

आधुनिक Kotlin कोड के लिए Coroutines पसंदीदा तरीका है। एंड्रॉइड UI कार्य के लिए `Handler` या `lifecycleScope`/`viewModelScope` के साथ कोरआउट्स का उपयोग करें।