¿Cómo inicializar un hilo en Kotlin?

En Java funciona aceptando un objeto que implementa ejecutable:

Thread myThread = new Thread(new myRunnable())

dónde myRunnable es una clase que implementa Runnable.

Pero cuando probé esto en Kotlin, parece que no funciona:

var myThread:Thread = myRunnable:Runnable

Kotlin viene con una función de biblioteca estándar threadque recomendaría usar aquí:

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

Puedes usarlo así:

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

Tiene muchos parámetros opcionales para, por ejemplo, no iniciar el hilo directamente configurando start a false.

Alternativas

Para inicializar una instancia de clase Threadinvoca a su constructor:

val t = Thread()

También puede pasar un opcional Runnable como lambda (conversión SAM) de la siguiente manera:

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

La versión más explícita pasaría una implementación anónima de Runnable como esto:

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

Tenga en cuenta que los ejemplos mostrados anteriormente solo crear una instancia de un Thread pero en realidad no lo inicies. Para lograr eso, necesitas invocar start() explícitamente.

Ejecutable:

val myRunnable = runnable {

}

Hilo:

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

No ves un Runnable aquí: en Kotlin se puede reemplazar fácilmente con una expresión lambda. ¿Hay una mejor manera? ¡Seguro! Así es como puede crear una instancia e iniciar un hilo al estilo Kotlin:

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

Hice lo siguiente y parece estar funcionando como se esperaba.

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

La mejor manera sería usar thread() función generadora de kotlin.concurrent:
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.concurrent/thread.html

Debe verificar sus valores predeterminados, ya que son bastante útiles:

thread() { /* do something */ }

Tenga en cuenta que no necesita llamar start() como en el ejemplo de Thread, o proporcionar start=true.

Tenga cuidado con los subprocesos que se ejecutan durante un largo período de tiempo. Es útil especificar thread(isDaemon= true) para que su aplicación pueda terminar correctamente.

Por lo general, la aplicación esperará hasta que finalicen todos los subprocesos que no sean demonios.

En primer lugar, cree una función para establecer la propiedad predeterminada

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

luego realice una operación en segundo plano llamando a esta función

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

O las rutinas de kotlin también se pueden usar para realizar tareas en segundo plano

GlobalScope.launch {

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

Ejemplo básico de Thread con Lamda

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

}

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

thread { /* your code here */ }