Wie Sie initialisiert einen Thread in Kotlin?

In Java es funktioniert durch die Annahme eines Objekt implementiert die runnable :

Thread myThread = new Thread(new myRunnable())

wo myRunnable ist eine Klasse Umsetzung Runnable.

Aber wenn ich versuchte dies in Kotlin, es scheint nicht zu funktionieren:

var myThread:Thread = myRunnable:Runnable

var myThread = Thread(myRunnable())
Es Hat Funktioniert!! Können Sie mir helfen zu verstehen, dieses Stück code?
Dabei myThread:Thread sagt, dass die variable myThread ist der Typ Thread. Und dabei myRunnable:Runnable hat keinen Sinn was so überhaupt. Initialisieren von Klassen in Kotlin ist sehr ähnlich zu Java. Sie entfernen Sie einfach das new Schlüsselwort. Relevante Kotlin-Dokumentation: , b
Danke. So x:X format funktioniert für Klassen, aber nicht für Schnittstellen?
Es funktioniert für Schnittstellen, aber wenn Sie das tun x = Y:y die Y:y Teil macht keinen Sinn.

InformationsquelleAutor Shubhranshu Jain | 2017-09-30

15

Zur Initialisierung ein Objekt der Thread Sie einfach den Konstruktur aufrufen:
```
val t = Thread()
```
Dann können Sie auch eine optionale Runnable mit einem lambda-SAM (Umwandlung) wie folgt:
```
Thread {
    Thread.sleep(1000)
    println("test")
}
```
Mehr explicit version übergeben wird eine anonyme Implementierung von Runnable wie diese:
```
Thread(Runnable {
    Thread.sleep(1000)
    println("test")
})
```
Beachten Sie, dass die zuvor gezeigten Beispiele stellen nur erstellen eine Instanz einer Thread aber eigentlich gar nicht starten. Um das zu erreichen, müssen Sie zum aufrufen start() ausdrücklich.

Last but not least, müssen Sie wissen, die standard-library-Funktion thread, die ich empfehlen würde zu verwenden:
```
public fun thread(start: Boolean = true, isDaemon: Boolean = false, contextClassLoader: ClassLoader? = null, name: String? = null, priority: Int = -1, block: () -> Unit): Thread {
```
Können Sie es verwenden, wie diese:
```
thread(start = true) {
    Thread.sleep(1000)
    println("test")
}
```
Es hat viele optionale Parameter für z.B. direktes starten der thread, wie hier gezeigt.

und damit der thread wird getötet, nachdem println?

InformationsquelleAutor s1m0nw1
2

Runnable:
```
val myRunnable = runnable {

}
```
Thread:
```
Thread({  
//call runnable here
  println("running from lambda: ${Thread.currentThread()}")
}).start()
```
Sieht man nicht einen Thread hier: in Kotlin es kann leicht ersetzt werden mit einem lambda-Ausdruck. Gibt es einen besseren Weg? Sicher!!! Hier ist, wie können Sie instanziieren und starten einer
thread Kotlin-Stil:
```
thread(start = true) {  
      println("running from thread(): ${Thread.currentThread()}")
    }
```
Sofern ich mehr Auswahl

InformationsquelleAutor Rajesh Dalsaniya
1

Versuchen Sie bitte diesen code:
```
Thread().run { Thread.sleep(3000); }
```
Versuchen Sie auch das hinzufügen einiger Erklärung
Während dieser kann die Frage beantworten, ist es besser zu erklären, die wesentliche Teile der Antwort, und möglicherweise, was war das problem mit OPs-code.

InformationsquelleAutor Hardeep singh
1

Habe ich Folgendes und es scheint zu funktionieren wie erwartet.
```
Thread(Runnable {
            //some method here
        }).start()
```
InformationsquelleAutor Adam Hurwitz
0

Beste Weg wäre, um thread() generator-Funktion von kotlin.concurrent:
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.concurrent/thread.html

Sollten Sie überprüfen Sie Ihre Standard-Werte, wie Sie sind sehr nützlich:
```
thread() { /* do something */ }
```
Beachten Sie, dass Sie brauchen nicht zu rufen start() wie in dem Thread Beispiel, oder bieten start=true.

Vorsichtig sein mit threads, die laufen für eine lange Zeit. Es ist nützlich, um anzugeben thread(isDaemon= true) so dass Ihre Anwendung wäre in der Lage zu beenden, richtig.

InformationsquelleAutor Alexey Soshin

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)
}

In der Regel ist es besser, zu erklären, eine Lösung, anstatt nur Entsendung einige Zeilen des anonymen code. Lesen Sie Wie Schreibe ich eine gute Antwort und auch Erklären völlig code-basierte Antworten

InformationsquelleAutor geekowll

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.