Kotlin 等待功能

Thread sleep always takes a time how long to wait: https://docs.oracle.com/javase/7/docs/api/java/lang/Thread.html#sleep(long)

public static void sleep(long millis)
throws InterruptedException

e.g.

Thread.sleep(1_000)  // wait for 1 second

If you want to wait for some other Thread to wake you, maybe `Object#wait()' would be better

https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#wait()

public final void wait()
throws InterruptedException

Then another thread has to call yourObject#notifyAll()

e.g. Thread1 and Thread2 shares an Object o = new Object()

Thread1: o.wait()      // sleeps until interrupted or notified
Thread2: o.notifyAll() // wake up ALL waiting Threads of object o

Please try this, it will work for Android:

Handler(Looper.getMainLooper()).postDelayed(
{
// This method will be executed once the timer is over
},
1000 // value in milliseconds
)

Since new coroutines feature became available in Kotlin version 1.1 you can use non-blocking delay function with such signature:

suspend fun delay(time: Long, unit: TimeUnit = TimeUnit.MILLISECONDS)

In Kotlin 1.2 it is still located in kotlinx.coroutines.experimental package. Experimental status of coroutines is described here.

UPD: Kotlin 1.3 was released, coroutines were moved to kotlinx.coroutines package, they are no longer experimental feature.

UPD 2: To use this method inside non-suspendable methods it's possible to make it blocking, like any other suspendable methods, by surrounding with runBlocking {}:

runBlocking {
delay(2, TimeUnit.SECONDS)
}

You can use stuff of the standard JDK.

Another response suggests Thread.sleep(millis: Long). Personally I prefer the TimeUnit class (since Java 1.5) which provides a more comprehensive syntax.

TimeUnit.SECONDS.sleep(1L)
TimeUnit.MICROSECONDS.sleep(1000_000L)

They use Thread.sleep behind the scene, and they can throw InterruptedException too. Unfortunately, as pointed by @AndroidDev in a comment, they do not cooperate with Kotlin coroutines (since Kotlin 1.1). So we should prefer delay function in this context.

public suspend fun delay(timeMillis: Long): Unit
public suspend fun delay(duration: Duration): Unit

You can achieve this easily with Kotlin coroutines

class SplashActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_splash)


CoroutineScope(Dispatchers.IO).launch {
delay(TimeUnit.SECONDS.toMillis(3))
withContext(Dispatchers.Main) {
Log.i("TAG", "this will be called after 3 seconds")
finish()
}
}
Log.i("TAG", "this will be called immediately")
}
}

build.gradle(app)

dependencies {
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.0.1'
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.0.1'
}

You can use

SystemClock.sleep(1000)

you can use to wait or sleep for 2 seconds

TimeUnit.SECONDS.sleep(2L)

TimeUnit.SECONDS.sleep((seconds you want to sleep) + L)