kotlin 中的延迟和 Thread.sleep 有什么区别

Question

I'm trying to figure out or to prove "how a delay is suspending function".
So, I wrote an example here

var time: Long? = null
    var job1 = GlobalScope.launch() {
        println("Coroutine ${Thread.currentThread().name}")
        time = measureTimeMillis {
            Thread.sleep(1000)
            println("After 1 seconds")
            Thread.sleep(1000)
            println("After 1 seconds")
            Thread.sleep(1000)
            println("After 1 seconds")
        }

    }
    println("Thread ${Thread.currentThread().name}")

    runBlocking {
        job1.join()
        println("Proccesed time is $time")
    }

the Output I got is

Thread main
Coroutine DefaultDispatcher-worker-1
After 1 seconds
After 1 seconds
After 1 seconds
Proccesed time is 3015

Then i replaced Thread.sleep with delay and still the processed time is 3045 ms .

I don't find any difference between Thread.sleep with delay .
How to prove that it is a Suspending Function and is different from Thread.sleep

Answer 1

The difference is that delay is a suspend function that won't block the thread, while Thread.sleep() will block the thread.

In other words, delay means that the coroutine suspends for that amount of time, which in turn means that the underlying Thread is free to go service a different coroutine which delays and suspends, and so on for all coroutines.

With Thread.sleep on the other hand, the underlying Thread cannot jump from coroutine to coroutine -- rather each Thread is blocked until all the sleeps in the coroutine are over before it can go service the execution of another coroutine.

To prove this to yourself with code, run a hundred of these coroutines instead of just 1. Then try it with a thousand. The Thread.sleep() version will take longer and longer to execute because the default coroutine dispatcher thread pool is quickly used up. On the other hand, the delay version will execute in just over 3 seconds, because there are no calls blocking the coroutine threads.

fun main() {
  var time: Long? = null
  time = measureTimeMillis {
    var jobs = (0..1_000).map {
      GlobalScope.launch {
        delay(1_000)
        print(".")
        delay(1_000)
        print(".")
        delay(1_000)
        print(".")
/*
        Thread.sleep(1_000)
        print(".")
        Thread.sleep(1_000)
        print(".")
        Thread.sleep(1_000)
        print(".")
*/
      }
    }

    runBlocking {
      jobs.joinAll()
    }
  }
  println("")
  println("Processed time is $time")
}

When coroutine code runs as it should -- without blocking calls like Thread.sleep() -- threads are always available to service coroutines that need to execute. If there is no suspending equivalent available to a blocking call (for example, a 3rd party library that does synchronous I/O), always encapsulate those calls within a dispatcher designed to run such blocking calls eg withContext(Dispatchers.IO) {... } , leaving the other coroutine dispatchers free to service non-blocking coroutines.

Answer 2

Suspending a thread means that thread will "wait" doing something else in the meantime if necessary. Blocking a thread means that thread will wait doing nothing no matter what.

You can prove that with this code:

fun log(message: String) {
    println("[${Thread.currentThread().name}] : $message")
}

fun main() {
    runBlocking {
        val myThread = newSingleThreadContext("My Thread")

        launch(myThread) {
            (1..3).forEach {
                log("1st launch: $it")
                //delay(1000)
                Thread.sleep(1000)
            }
        }

        launch(myThread) {
            (1..3).forEach {
                log("2nd launch: $it")
                //delay(1000)
                Thread.sleep(1000)
            }
        }
    }
}

Output with delay :

[My Thread] : 1st launch: 1
[My Thread] : 2nd launch: 1
[My Thread] : 1st launch: 2
[My Thread] : 2nd launch: 2
[My Thread] : 1st launch: 3
[My Thread] : 2nd launch: 3

Output with Thread.sleep :

[My Thread] : 1st launch: 1
[My Thread] : 1st launch: 2
[My Thread] : 1st launch: 3
[My Thread] : 2nd launch: 1
[My Thread] : 2nd launch: 2
[My Thread] : 2nd launch: 3

Since delay is a suspending function it can be called only from inside a coroutine or from another suspending function.

Answer 3

I only will try to answer in a very simple way.

fun main() = runBlocking<Unit> {

    launch {
        Thread.sleep(3000L)
     // delay(3000L)
        println("Coroutine 1 ${Thread.currentThread().name}")
    }

    launch {
        println("Coroutine 2 ${Thread.currentThread().name}")
    }
}

Using Thread.sleep

• Here I have used runBlocking to wrap the execution of the main function. Which allows me to use launch keyword directly as it runs on context of runBlocking .
• both the launch coroutine will run on the main Thread. Which can be seen by printing the thread name.
• When Thread.sleep(3000L) is put inside first launch. The output is

Coroutine 1 main
Coroutine 2 main

This is because, when first coroutine is executed it will come at Thread.sleep(3000L) which in turns block the main thread. So, main thread is blocked and it will not handle other threads for 3 seconds.

Then after 3 seconds Coroutine 1 main will get printed. and then Coroutine 2 main will be printed

Using delay

• now replace Thread.sleep(3000L) by delay(3000L)
• now when first coroutine is executed it will come at delay(3000L) which suspends the main thread.
• now main Thread will not wait for 3 seconds instead it will start executing other coroutines.
• Hence, it will execute coroutine 2 and prints Coroutine 2 main first.
• on back end after the delay of 3 second is over by coroutine 1. Then main Thread go back to Coroutine 1 and prints Coroutine 1 main
• So, output will be

Coroutine 2 main
Coroutine 1 main

Hence, we can prove that Thread.sleep will blocking the thread, whereas delay is just suspending the thread.