Comment initialiser un Thread dans Kotlin?

En Java, il fonctionne par l'acceptation d'un objet qui implémente runnable :

Thread myThread = new Thread(new myRunnable())

où myRunnable est une classe implémentant Runnable.

Mais quand j'ai essayé ceci dans Kotlin, il ne semble pas fonctionner:

var myThread:Thread = myRunnable:Runnable
  • var myThread = Thread(myRunnable())
  • Il A Travaillé!! Pouvez-vous m'aider à comprendre ce bout de code?
  • Faire myThread:Thread dit que la variable myThread est de type Thread. Et de faire myRunnable:Runnable n'a pas de sens, afin que jamais. L'initialisation des classes dans Kotlin est très similaire à Java. Vous venez de supprimer la new mot-clé. Pertinentes Kotlin de la documentation: une, b
  • Merci. Donc x:X le format des œuvres pour les classes, mais pas pour les interfaces?
  • Il fonctionne pour les interfaces, mais quand vous ne x = Y:y la Y:y partie n'a pas de sens.
  • Vous devriez jeter un oeil à ce guide pour la syntaxe de base sur la définition de la variable et de l'instance.

InformationsquelleAutor Shubhranshu Jain | 2017-09-30
  1. 20

    Pour l'initialisation d'un objet de Thread vous suffit de l'appeler le constructeur: 

    val t = Thread()

    Ensuite, vous pouvez également passer une option Runnable avec un lambda de SAM (Conversion) comme ceci:

    Thread {
    Thread.sleep(1000)
    println("test")
}

    Le plus explicite version est le passage d'un anonyme de la mise en œuvre de Runnable comme ceci:

    Thread(Runnable {
    Thread.sleep(1000)
    println("test")
})

    Remarque que précédemment montré des exemples ne faire que créer une instance d'un Thread mais n'est pas réellement commencer. Pour y parvenir, vous avez besoin d'invoquer start() explicitement.

    Dernier mais non le moindre, vous devez savoir de la bibliothèque standard de la fonction thread, que je vous recommande d'utiliser:

    public fun thread(start: Boolean = true, isDaemon: Boolean = false, contextClassLoader: ClassLoader? = null, name: String? = null, priority: Int = -1, block: () -> Unit): Thread {

    Vous pouvez l'utiliser comme ceci:

    thread(start = true) {
    Thread.sleep(1000)
    println("test")
}

    Il a beaucoup de paramètres facultatifs pour par exemple directement de départ le fil comme illustré ici. Notez que true est la valeur par défaut de start de toute façon.

    • et donc, le fil est tué après println?
    • Notez que vous pouvez omettre start = true (parce que start est true par défaut) et il suffit d'écrire thread { Thread.sleep(1000) } pour commencer thread.
    • J'ai ajouté une note à ce sujet pour le rendre plus évident, merci
    InformationsquelleAutor s1m0nw1
  2. 5

    Praticable:

    val myRunnable = runnable {

}

    Fil:

    Thread({  
//call runnable here
  println("running from lambda: ${Thread.currentThread()}")
}).start()

    Vous ne voyez pas un Exécutable ici: dans Kotlin, il peut facilement être remplacé par une expression lambda. Est-il un meilleur moyen? Bien sûr! Voici comment vous pouvez instancier et de commencer une
    fil Kotlin-style:

    thread(start = true) {  
      println("running from thread(): ${Thread.currentThread()}")
    }
    • J'ai fourni plus de choix
    InformationsquelleAutor Rajesh Dalsaniya
  3. 2

    Je n'ai la suite et il semble fonctionner comme prévu.

    Thread(Runnable {
            //some method here
        }).start()
    InformationsquelleAutor Adam Hurwitz
  4. 1

    Meilleur moyen serait d'utiliser thread() fonction de générateur de kotlin.concurrent:
    https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.concurrent/thread.html

    Vous devriez vérifier ses valeurs par défaut, comme ils sont très utiles:

    thread() { /* do something */ }

    Notez que vous n'avez pas besoin d'appeler start() comme dans le Thread exemple, ou de fournir start=true.

    Être prudent avec les threads qui s'exécutent pendant une longue période de temps. Il est utile de préciser thread(isDaemon= true) de sorte que votre application serait en mesure de terminer correctement.

    InformationsquelleAutor Alexey Soshin
  5. 0

    S'il vous plaît essayez ce code:

    Thread().run { Thread.sleep(3000); }
    • Aussi essayer d'ajouter quelques explications
    • Même si cela peut répondre à la question, il est préférable d'expliquer l'essentiel des éléments de réponse et, éventuellement, quel était le problème avec OPs code.
    • Ce code ne résout pas le problème: il ne sait pas démarrer nouveau thread mais s'exécute Thread.sleep(3000) dans le thread en cours à la place (à l'aide de Kotlin général de run méthode d'extension qui obtient nouvellement créée fil à un récepteur, mais ne fait rien avec elle).
    InformationsquelleAutor Hardeep singh
  6. 0
    fun main(args: Array<String>) {

    Thread({
        println("test1")
        Thread.sleep(1000)
    }).start()

    val thread = object: Thread(){
        override fun run(){
            println("test2")
            Thread.sleep(2000)
        }
    }

    thread.start()

    Thread.sleep(5000)
}
    InformationsquelleAutor hgedek
  7. 0

    Exemple de base de la Thread avec Lamda

    fun main() {
    val mylamda = Thread({
        for (x in 0..10){
            Thread.sleep(200)
            println("$x")
        }
   })
    startThread(mylamda)

}

fun startThread(mylamda: Thread) {
    mylamda.start()
}
    InformationsquelleAutor Geet Thakur