Suspendre l'exécution d'un thread avec Sleep en Kotlin

Utilisez Thread.sleep lorsque du code Kotlin/JVM synchrone doit mettre en pause le thread courant. Utilisez TimeUnit.sleep lorsqu’une unité nommée rend le délai plus lisible. Dans une coroutine, utilisez delay pour la suspendre sans bloquer son thread ; pour une tâche à exécuter plus tard, utilisez plutôt ScheduledExecutorService. Tout thread en sommeil peut être interrompu, et un délai est une attente minimale, pas un instant d’exécution exact.

Une coroutine est le terme technique désignant une unité d’exécution non bloquante.

Bloquer le thread courant avec Thread.sleep

Thread.sleep(milliseconds) est l’opération JVM directe qui met en pause le thread appelant. L’argument est un nombre Long de millisecondes et la méthode lève InterruptedException. En production, restaurez le drapeau d’interruption ou propagez l’interruption au lieu d’imprimer simplement une trace.

fun main() {
    println("before")
    try {
        Thread.sleep(100L)
        println("after")
    } catch (exception: InterruptedException) {
        Thread.currentThread().interrupt()
        println("interrupted")
    }
}

Sortie :

before
after

Cela bloque le thread appelant pendant au moins environ 100 millisecondes. La JVM entière ne s’arrête pas : d’autres threads prêts peuvent continuer. Évitez cette méthode dans une boucle d’événements ou sur un worker limité si le travail peut être exprimé comme une suspension non bloquante.

Utiliser des unités lisibles avec TimeUnit.sleep

TimeUnit, fourni par java.util.concurrent, convertit une unité nommée comme les secondes ou les millisecondes avant la pause. Il bloque toujours le thread courant et répond toujours aux interruptions, mais TimeUnit.SECONDS.sleep(1) est plus facile à relire qu’une conversion littérale en millisecondes.

import java.util.concurrent.TimeUnit

fun main() {
    println("before")
    try {
        TimeUnit.MILLISECONDS.sleep(100)
        println("after")
    } catch (exception: InterruptedException) {
        Thread.currentThread().interrupt()
        println("interrupted")
    }
}

Sortie :

before
after

Choisissez l’unité adaptée au besoin. La conversion ne garantit pas une durée exacte : l’ordonnancement, la contention ou la résolution du minuteur du système peuvent retarder la reprise du thread.

Utiliser delay dans une coroutine

delay est une fonction suspensive de kotlinx-coroutines-core. Elle met la coroutine en pause sans bloquer le thread sous-jacent, qui peut alors servir à une autre coroutine. Appelez-la depuis une fonction suspensive ou un scope de coroutine ; elle ne remplace pas Thread.sleep dans du code synchrone ordinaire.

Par exemple, un scope runBlocking peut lancer une coroutine qui appelle delay(100L) puis affiche un message. L’ordre dépend de l’ordonnancement ; l’annulation est une limite importante : delay est annulable, une coroutine annulée s’arrête donc normalement au point de suspension. Ajoutez la dépendance kotlinx-coroutines-core avant de compiler ; la bibliothèque standard Kotlin ne fournit pas delay seule.

Planifier une tâche avec ScheduledExecutorService

Utilisez ScheduledExecutorService si le besoin est « exécuter cette tâche plus tard » plutôt que « endormir le thread courant ». Une tâche planifiée peut être annulée avant son exécution et l’exécuteur doit être arrêté lorsqu’il n’est plus utile.

import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit

fun main() {
    val executor = Executors.newSingleThreadScheduledExecutor()
    val task = executor.schedule(
        { println("task ran") },
        100,
        TimeUnit.MILLISECONDS,
    )

    task.get()
    executor.shutdown()
}

Sortie :

task ran

Ici, get() sert uniquement à garder cet exemple en ligne de commande actif jusqu’à la fin de la tâche. Dans une application, conservez le ScheduledFuture renvoyé si vous devez annuler la tâche et utilisez shutdown ou shutdownNow selon le cycle de vie voulu. La planification ne garantit pas un temps réel précis.

Quelle méthode Sleep de Kotlin choisir ?

• Utilisez Thread.sleep pour une petite opération JVM synchrone où le blocage du thread courant est volontaire.
• Utilisez TimeUnit.sleep pour le même comportement bloquant avec une unité lisible.
• Utilisez delay dans les coroutines pour une suspension annulable et non bloquante.
• Utilisez ScheduledExecutorService lorsqu’une tâche distincte doit être déclenchée après un délai.

N’utilisez pas wait() comme opération Sleep générale. Object.wait() de Java participe à la coordination des moniteurs et exige le moniteur approprié ; il répond à un autre problème de synchronisation. Avec toute API, considérez interruption et annulation comme des issues normales du contrôle, non comme des erreurs inattendues.