本文首发于公众号“AntDream”，欢迎微信搜索“AntDream”或扫描文章底部二维码关注，和我一起每天进步一点点

Kotlin 中的 delay 函数和 Java 中的 Thread.sleep 都用于暂停代码执行，但是它们用于不同的场景，并且有不同的实现和影响。理解它们的不同点能帮助我们在合适的场景中选择合适的工具来提升效率和代码的可读性。

Thread.sleep 简介

Thread.sleep 是 Java 提供的方法，用于暂停当前线程的执行。它是一个阻塞操作，会冻结当前线程一段时间。

try {
    Thread.sleep(1000); // 暂停 1 秒
} catch (InterruptedException e) {
    e.printStackTrace();
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.

在 Kotlin 中使用 Thread.sleep：

fun main() {
    println("Start")
    Thread.sleep(1000) // 暂停 1 秒
    println("End")
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
delay 简介

delay 函数是 Kotlin 协程库（Kotlin Coroutines）提供的一个挂起函数，用于暂停协程的执行而不会阻塞线程。

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Start")
    delay(1000) // 暂停 1 秒
    println("End")
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
详细对比

以下是 delay 和 Thread.sleep 在实现方式和应用场景中的详细对比：

1. 阻塞 vs 非阻塞
  • Thread.sleep: 阻塞当前线程，线程被暂停，不能执行其他任务。
fun main() {
    println("Before sleep")
    Thread.sleep(1000) // 阻塞当前线程 1 秒
    println("After sleep")
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • delay: 非阻塞，在此期间可让出线程执行其他协程任务。
import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Before delay")
    delay(1000) // 挂起 1 秒，但不会阻塞线程
    println("After delay")
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
2. 多任务处理
  • Thread.sleep: 如果当前线程内有多个任务，使用 sleep 会阻塞所有任务。
fun main() {
    println("Task 1 start")
    Thread.sleep(1000)
    println("Task 1 end")

    println("Task 2 start")
    Thread.sleep(1000)
    println("Task 2 end")
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • delay: 在协程中，使用 delay 不会阻塞线程，可以让其他协程继续执行。
import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("Task 1 start")
        delay(1000)
        println("Task 1 end")
    }

    launch {
        println("Task 2 start")
        delay(1000)
        println("Task 2 end")
    }
    
    delay(2000) // 主协程等待所有任务完成
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
3. CPU 资源的有效利用
  • Thread.sleep: 在使用 sleep 时，线程暂停，占用的资源不能被释放和共享。
  • delay: 在协程中使用 delay 可以释放线程的资源，让其他任务可以被调度，因此更有效地利用 CPU。
结论
  • Thread.sleep：适用于简单的同步操作，线程处于阻塞状态，使用非常容易，但会导致资源不能被其他任务利用。
  • delay：是协程中的挂起函数，不阻塞线程，适用于并发和异步任务，可以高效利用系统资源。这也是 Kotlin 推荐在协程中使用 delay 而不是 Thread.sleep 的原因。

理解 delay 和 Thread.sleep 的区别可以更好地选择合适的方法来实现并发和异步任务，从而提升应用的性能和可维护性。

欢迎关注我的公众号AntDream查看更多精彩文章！