如果你正在使用最新的Android api, Handler空构造函数已经被弃用，你应该包括一个循环程序。你可以很容易地通过loop . getmainlooper()得到一个。

    Handler(Looper.getMainLooper()).postDelayed({
        //Your code
    }, 2000) //millis

我推荐使用SingleThread，因为你不需要在使用后杀死它。此外，“stop()”方法在Kotlin语言中已弃用。

private fun mDoThisJob(){

    Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate({
        //TODO: You can write your periodical job here..!

    }, 1, 1, TimeUnit.SECONDS)
}

此外，您可以使用它定期工作。它非常有用。如果你想在每一秒内完成一个任务，你可以设置它的参数:

Executors.newSingleThreadScheduledExecutor()。scheduleAtFixedRate(可运行命令，长initialDelay，长周期，TimeUnit unit);

时间单位值是:纳秒，微秒，毫秒，秒，分钟，小时，天。

很多方面

1. 使用Handler类

Handler().postDelayed({
    TODO("Do something")
    }, 2000)

2. 使用Timer类

Timer().schedule(object : TimerTask() {
    override fun run() {
        TODO("Do something")
    }
}, 2000)

// Shorter

Timer().schedule(timerTask {
    TODO("Do something")
}, 2000)


// Shortest

Timer().schedule(2000) {
    TODO("Do something")
}

3.使用Executors类

Executors.newSingleThreadScheduledExecutor().schedule({
    TODO("Do something")
}, 2, TimeUnit.SECONDS)

一个简单的例子来展示3秒后的祝酒词:

fun onBtnClick() {
    val handler = Handler()
    handler.postDelayed({ showToast() }, 3000)
}

fun showToast(){
    Toast.makeText(context, "Its toast!", Toast.LENGTH_SHORT).show()
}

我使用以下函数:

fun <T> delayedAsyncTask(delayMs: Long = 0, task: () -> T): ScheduledFuture<T> {
    return Executors
        .newSingleThreadScheduledExecutor()
        .schedule(Callable<T> { task() }, delayMs, TimeUnit.MILLISECONDS)
}

fun <T> asyncTask(task: () -> T) = delayedAsyncTask(0, task)

这是一个延迟函数的单元测试。当然，使用返回的将来是可选的。

    @Test
    fun `delayed task work correctly`() {
        val future = delayedAsyncTask(1000) {
            "lambda returns hello world"
        }
        assertEquals(false, future.isDone)
        Thread.sleep(1100)
        assertEquals(true, future.isDone)
        assertEquals("lambda returns hello world", future.get())
    }

还有一个选项使用Handler -> postDelayed

 Handler().postDelayed({
                    //doSomethingHere()
                }, 1000)