Utiliser la fonction Kotlin Sleep pour suspendre l'exécution d'un thread

1. Utilisation de la fonction Kotlin Thread.Sleep()
2. Utilisation de la fonction Kotlin TimeUnit Sleep()
3. Utilisation de la fonction Kotlin Delay()

Java a une fonction wait() qui interrompt l’exécution du thread en cours. Le thread dort jusqu’à ce qu’un autre thread entre et notifie le thread endormi.

Mais existe-t-il un équivalent disponible dans Kotlin ? Kotlin n’a pas la fonction wait(), mais il a la fonction sleep().

La fonction Kotlin sleep() suspend l’exécution d’une coroutine particulière. Bien que cela ne suspende pas l’exécution, cela permet l’exécution d’autres coroutines.

Cet article enseigne comment utiliser la fonction sleep() dans Kotlin. En plus de cela, nous apprendrons également une autre façon de suspendre une coroutine en utilisant la fonction delay().

Utilisation de la fonction Kotlin Thread.Sleep()

Nous pouvons utiliser la fonction Thread.sleep() pour mettre une coroutine en veille et permettre à d’autres coroutines indépendantes de s’exécuter.

La syntaxe d’utilisation de la fonction sleep() est la suivante :

Thread.sleep(milliseconds)

Voici un exemple où nous utilisons la fonction Kotlin sleep() pour suspendre l’exécution d’une coroutine de 3 secondes.

fun main() {

    println("Suspending execution")

    try {
        // making the coroutine sleep for 3 seconds
        Thread.sleep(3000)
    } catch (e: InterruptedException) {
        e.printStackTrace()
    }

    println("Resuming execution")
}

Production:

Utilisation de la fonction Kotlin TimeUnit Sleep()

Comme Thread.sleep(), nous pouvons également utiliser TimeUnit pour suspendre l’exécution d’un thread.

Alors que la technique Thread n’accepte que le nombre de millisecondes en entrée, TimeUnit accepte 7 unités de temps différentes. Ces 7 unités de temps sont :

1. Nanosecondes
2. Microsecondes
3. Millisecondes
4. Secondes
5. minutes
6. heures
7. jours

Le TimeUnit convertit automatiquement la valeur passée en millisecondes, ce que la fonction sleep() accepte.

Les méthodes TimeUnit font partie de la bibliothèque java.util.concurrent. Par conséquent, nous devons importer la bibliothèque concurrente pour utiliser cette méthode.

Voici un exemple démontrant la fonction Kotlin sleep() de TimeUnit.

import java.util.concurrent.TimeUnit

fun main() {
    println("Suspending execution")

    try {
        // // making the coroutine sleep for 3 seconds
        TimeUnit.SECONDS.sleep(3)
    } catch (e: InterruptedException) {
        e.printStackTrace()
    }
    println("Resuming execution")
}

Production:

Utilisation de la fonction Kotlin Delay()

Outre la fonction sleep() de Kotlin, nous pouvons également utiliser la fonction delay() pour suspendre l’exécution d’une coroutine. La fonction delay() accepte également les millisecondes en entrée.

Voici un exemple pour montrer l’utilisation de la fonction Kotlin delay().

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch { // launches a new coroutine
        delay(2000L) // This delays the execution by 2 seconds allowing other coroutines to run independently
        println("welcome!") // This will be printed after the delay
    }
    print("Hi and ") // This will be printed first since the other coroutine is delayed
}

Production: