[kotlin]处理延时操作

在 Kotlin 中处理延迟操作可以通过多种方式实现，每种方式都适用于不同的场景和需求。

1. 使用 Handler

这是一种在 Android 开发中常见的方法，适用于需要在一定时间后执行某些操作的场景。

import android.os.Handler
import android.os.Looper

// 创建一个 Handler 对象
val handler = Handler(Looper.getMainLooper())

// 使用 postDelayed 方法执行延迟操作
handler.postDelayed({
    // 这里放置延迟后要执行的代码
    println("延迟操作执行")
}, 2000)  // 延迟2000毫秒（2秒）

2. 使用 Kotlin 协程

Kotlin 的协程提供了一个现代且强大的异步处理解决方案，适用于需要在非阻塞方式下执行延迟操作的场景。

import kotlinx.coroutines.*

// 在协程作用域中执行
GlobalScope.launch(Dispatchers.Main) {
    delay(2000)  // 协程延迟2000毫秒（2秒）
    println("协程中的延迟执行")
}

3. 使用 Timer

Timer 和 TimerTask 也可以用来实现延迟功能，这种方式相较于 Handler 更为通用，但在 Android 中不推荐用于更新UI。

import java.util.Timer
import java.util.TimerTask

// 创建一个 Timer 对象
val timer = Timer()

// 安排一个任务在延迟后执行
timer.schedule(object : TimerTask() {
    override fun run() {
        println("Timer 延迟执行")
    }
}, 2000)  // 延迟2000毫秒（2秒）

4. 使用 ScheduledExecutorService

这是 Java 提供的一个更为强大的定时器工具，适用于需要精确控制多个定时任务的场景。

import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit

// 创建 ScheduledExecutorService
val scheduler = Executors.newScheduledThreadPool(1)

// 安排在一定的延迟后执行任务
scheduler.schedule({
    println("ScheduledExecutorService 延迟执行")
}, 2, TimeUnit.SECONDS)  // 延迟2秒

5. 使用 Object.wait()

这是一个更底层的方法，通过在同步块中使用 wait() 来实现延迟，不过这种方法需要精确的线程控制，且容易造成线程阻塞。

val lock = Object()

synchronized(lock) {
    try {
        lock.wait(2000)  // 在锁对象上等待2000毫秒（2秒）
        println("Object.wait() 延迟执行")
    } catch (e: InterruptedException) {
        e.printStackTrace()
    }
}