Timeout with withTimeout in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin code using withTimeout?

Consider the following Kotlin code snippet using withTimeout. What will be printed when this code runs?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    try {
        withTimeout(1000L) {
            repeat(5) { i ->
                println("Processing $i")
                delay(400L)
            }
        }
    } catch (e: TimeoutCancellationException) {
        println("Timeout occurred")
    }
}

A

Processing 0
Processing 1
Processing 2
Timeout occurred

B

Processing 0
Processing 1
Processing 2
Processing 3
Processing 4

C Timeout occurred

D

Processing 0
Timeout occurred

💡 Hint

Think about how long each delay takes and the total timeout limit.

The code tries to process 5 items with 400ms delay each, totaling 2000ms. The timeout is 1000ms, so it cancels during the third iteration after printing 'Processing 2'. Then it catches the timeout exception and prints 'Timeout occurred'.

❓ Predict Output

intermediate

What happens if delay exceeds withTimeout duration?

What will be the output of this Kotlin code snippet?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    try {
        withTimeout(500L) {
            delay(1000L)
            println("Finished")
        }
    } catch (e: TimeoutCancellationException) {
        println("Timeout!")
    }
}

A Timeout!

B Finished

C No output

D RuntimeException

💡 Hint

The delay is longer than the timeout duration.

The delay of 1000ms exceeds the 500ms timeout, so the coroutine is cancelled and the catch block prints 'Timeout!'.

🔧 Debug

advanced

Identify the error in this withTimeout usage

This Kotlin code snippet is intended to timeout after 1 second, but it does not behave as expected. What is the error?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    withTimeout(1000L) {
        repeat(3) { i ->
            println("Step $i")
            Thread.sleep(500L)
        }
    }
    println("Done")
}

A withTimeout requires delay, not Thread.sleep, otherwise it throws an exception.

B Using Thread.sleep blocks the thread and prevents cancellation, so timeout does not work.

C The timeout value is too short to complete the loop, causing an immediate cancellation.

D runBlocking cannot be used with withTimeout.

💡 Hint

Consider how blocking calls affect coroutine cancellation.

Thread.sleep blocks the thread and does not cooperate with coroutine cancellation, so withTimeout cannot interrupt it. Using delay is required for proper timeout behavior.

📝 Syntax

advanced

Which option correctly uses withTimeout to return a value?

Select the Kotlin code snippet that correctly uses withTimeout to return a value from a suspending block.

A

val result = withTimeout(1000L) {
    delay(500L)
    println("Success")
}
println(result)

B

val result = withTimeout(1000L) {
    delay(500L)
    return "Success"
}
println(result)

C

val result = withTimeout(1000L) {
    delay(500L)
    "Success"
}
println(result)

D

val result = withTimeout(1000L) {
    delay(500L)
    "Success"
}
return result
println(result)

💡 Hint

Remember how to return values from lambda blocks in Kotlin.

Option C correctly returns the string "Success" from the withTimeout block and assigns it to result. Option C uses 'return' inside lambda which is invalid here. Option C returns Unit because println returns Unit. Option C has unreachable code after return.

🚀 Application

expert

How to handle multiple withTimeout calls with different durations?

You want to run two suspending tasks sequentially with different timeouts: first task with 1 second timeout, second with 2 seconds timeout. Which Kotlin code snippet correctly implements this?

A

runBlocking {
    val first = withTimeout(1000L) {
        delay(900L)
        "First"
    }
    val second = withTimeout(2000L) {
        delay(1500L)
        "Second"
    }
    println("$first and $second")
}

B

runBlocking {
    withTimeout(3000L) {
        val first = delay(900L)
        val second = delay(1500L)
        println("First and Second")
    }
}

C

runBlocking {
    val first = withTimeout(1000L) {
        delay(1100L)
        "First"
    }
    val second = withTimeout(2000L) {
        delay(1500L)
        "Second"
    }
    println("$first and $second")
}

D

runBlocking {
    val first = withTimeoutOrNull(1000L) {
        delay(1100L)
        "First"
    } ?: "Timeout"
    val second = withTimeoutOrNull(2000L) {
        delay(1500L)
        "Second"
    } ?: "Timeout"
    println("$first and $second")
}

💡 Hint

Consider how to handle tasks that might timeout without throwing exceptions.

Option D uses withTimeoutOrNull to safely handle timeouts by returning null instead of throwing exceptions. It assigns "Timeout" if the task exceeds its timeout. This is the best way to run multiple tasks with different timeouts sequentially and handle possible cancellations gracefully.