Wie initialisiere ich einen Thread in Kotlin?

Lesezeit: 3 Minuten

Benutzeravatar von Shubhranshu Jain
Shubhranshu Jain

In Java funktioniert es, indem es ein Objekt akzeptiert, das runnable implementiert:

Thread myThread = new Thread(new myRunnable())

Wo myRunnable ist eine Klasse, die implementiert Runnable.

Aber als ich das in Kotlin ausprobiert habe, scheint es nicht zu funktionieren:

var myThread:Thread = myRunnable:Runnable

  • var myThread = Thread(myRunnable())

    – Mibac

    30. September 2017 um 17:57 Uhr

  • @Mibac Es hat funktioniert!! Können Sie mir helfen, dieses Stück Code zu verstehen?

    – Shubhranshu Jain

    30. September 2017 um 18:04 Uhr

  • Tun myThread:Thread sagt diese Variable myThread ist vom Typ Thread. Und tun myRunnable:Runnable hat überhaupt keinen Sinn. Das Initialisieren von Klassen in Kotlin ist Java sehr ähnlich. Sie entfernen einfach die new Stichwort. Relevante Kotlin-Dokumentation: A, B

    – Mibac

    30. September 2017 um 18:05 Uhr


  • Danke. Das x:X-Format funktioniert also für Klassen, aber nicht für Schnittstellen?

    – Shubhranshu Jain

    30. September 2017 um 18:19 Uhr

  • Es funktioniert für Schnittstellen, aber wenn Sie es tun x = Y:y Die Y:y Teil macht keinen Sinn.

    – Mibac

    30. September 2017 um 18:52 Uhr

Benutzeravatar von s1m0nw1
s1m0nw1

Kotlin verfügt über eine Standardbibliotheksfunktion threaddie ich hier empfehlen würde:

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

Sie können es wie folgt verwenden:

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

Es hat viele optionale Parameter, um zB den Thread nicht direkt per Einstellung zu starten start Zu false.


Alternativen

Um eine Instanz der Klasse zu initialisieren Threadrufen Sie seinen Konstruktor auf:

val t = Thread()

Sie können auch eine optionale übergeben Runnable als Lambda (SAM-Konvertierung) wie folgt:

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

Die explizitere Version würde eine anonyme Implementierung von übergeben Runnable so was:

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

Beachten Sie, dass die zuvor gezeigten Beispiele dies nur tun erstellen eine Instanz von a Thread aber nicht wirklich starten. Um das zu erreichen, müssen Sie aufrufen start() ausdrücklich.

  • Beachten Sie, dass Sie weglassen können start = true (Weil start Ist true standardmäßig) und einfach schreiben thread { Thread.sleep(1000) } Thread zu beginnen.

    – Ilya Serbis

    27. Mai 2019 um 8:30 Uhr

  • Ich habe eine Anmerkung dazu hinzugefügt, um es deutlicher zu machen, danke

    – s1m0nw1

    27. Mai 2019 um 9:57 Uhr

Benutzeravatar von Rajesh Dalsaniya
Rajesh Dalsaniya

Lauffähig:

val myRunnable = runnable {

}

Gewinde:

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

Sie sehen hier kein Runnable: In Kotlin kann es einfach durch einen Lambda-Ausdruck ersetzt werden. Gibt es einen besseren Weg? Sicher! So können Sie einen Thread im Kotlin-Stil instanziieren und starten:

thread(start = true) {  
      println("running from thread(): ${Thread.currentThread()}")
    }

  • @Mibac Ich habe mehr Auswahlmöglichkeiten bereitgestellt

    – Rajesh Dalsaniya

    30. September 2017 um 18:53 Uhr

Ich habe folgendes gemacht und es scheint wie erwartet zu funktionieren.

Thread(Runnable {
            //some method here
        }).start()

Benutzeravatar von Alexey Soshin
Alexej Soschin

Der beste Weg wäre zu verwenden thread() Generatorfunktion aus kotlin.concurrent:
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.concurrent/thread.html

Sie sollten die Standardwerte überprüfen, da sie sehr nützlich sind:

thread() { /* do something */ }

Beachten Sie, dass Sie nicht anrufen müssen start() wie im Thread Beispiel, oder erstellen start=true.

Seien Sie vorsichtig mit Threads, die über einen langen Zeitraum ausgeführt werden. Es ist nützlich zu spezifizieren thread(isDaemon= true) damit Ihre Anwendung ordnungsgemäß beendet werden kann.

Normalerweise wartet die Anwendung, bis alle Nicht-Daemon-Threads beendet sind.

Erstellen Sie zunächst eine Funktion zum Festlegen der Standardeigenschaft

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

Führen Sie dann eine Hintergrundoperation durch, die diese Funktion aufruft

thread(start = true) {
     //Do background tasks...
}

Oder Kotlin-Coroutinen können auch verwendet werden, um Hintergrundaufgaben auszuführen

GlobalScope.launch {

    //TODO("do background task...")
    withContext(Dispatchers.Main) {
        // TODO("Update UI")
    }
    //TODO("do background task...")
}

Holen Sie sich den Benutzeravatar von Thakur
Hol Thakur

Grundlegendes Beispiel für Thread mit Lamda

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

}

fun startThread(mylamda: Thread) {
    mylamda.start()
}

Benutzeravatar von David Callanan
David Callanan

thread { /* your code here */ }

1444290cookie-checkWie initialisiere ich einen Thread in Kotlin?

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy