How to initialize a Thread in Kotlin?

Question

In Java it works by accepting an object which implements runnable :

Thread myThread = new Thread(new myRunnable())

where myRunnable is a class implementing Runnable.

But when I tried this in Kotlin, it doesn't seems to work:

var myThread:Thread = myRunnable:Runnable

Answer 1

Best way would be to use thread() generator function from kotlin.concurrent: https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.concurrent/thread.html

You should check its default values, as they're quite useful:

thread() { /* do something */ }

Note that you don't need to call start() like in the Thread example, or provide start=true.

Be careful with threads that run for a long period of time. It's useful to specify thread(isDaemon= true) so your application would be able to terminate correctly.

Answer 2

Basic example of Thread with Lamda

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

}

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

Answer 3

Please try this code:

Thread().run { Thread.sleep(3000); }

Answer 4

For initialising an object of Thread you simply invoke the constructor:

val t = Thread()

Then, you can also pass an optional Runnable with a lambda (SAM Conversion) like this:

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

The more explicit version is passing an anonymous implementation of Runnable like this:

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

Note that the previously shown examples do only create an instance of a Thread but don't actually start it. In order to achieve that, you need to invoke start() explicitly.

Last but not least, you need to know the standard library function thread, which I'd recommend to use:

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

You can use it like this:

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

It has many optional parameters for e.g. directly starting the thread as shown here. Note that true is the default value of start anyway.

Answer 5

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

Answer 6

Firstly, create a function for set default propery

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

then perform background operation calling this function

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

Or kotlin coroutines also can be used to perform background task

GlobalScope.launch {

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