Timeout with withTimeout in Kotlin - Step-by-Step Execution

Concept Flow - Timeout with withTimeout

Start Coroutine

↓

Call withTimeout

↓

Start block inside withTimeout

↓

Check elapsed time

↓

Throw TimeoutCancellationException

↓

Complete block

↓

Return result or Exception

The coroutine starts with withTimeout, runs the block, checks elapsed time, and throws an exception if time exceeds the limit.

Execution Sample

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
  withTimeout(1000) {
    repeat(5) {
      delay(300)
      println("Tick $it")
    }
  }
}

This code runs a block with a 1-second timeout, printing ticks every 300ms until timeout occurs.

Execution Table

Step	Elapsed Time (ms)	Action	Output	Timeout Check
1	0	Start withTimeout block		Not exceeded
2	300	delay(300), print Tick 0	Tick 0	Not exceeded
3	600	delay(300), print Tick 1	Tick 1	Not exceeded
4	900	delay(300), print Tick 2	Tick 2	Not exceeded
5	1200	delay(300), attempt print Tick 3		Exceeded - throw TimeoutCancellationException

💡

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	Final
Elapsed Time (ms)	0	300	600	900	1200	Timeout Exception thrown
Tick Count (it)	-	0	1	2	3	-

Key Moments - 2 Insights

Why does the program stop after printing Tick 2 and not continue to Tick 4?

Because at step 5, elapsed time exceeds the 1000ms timeout, so withTimeout throws TimeoutCancellationException and stops execution (see execution_table row 5).

Does withTimeout cancel the coroutine immediately when time is exceeded?

Yes, as soon as elapsed time exceeds the timeout, withTimeout throws an exception to cancel the coroutine (execution_table step 5).

Visual Quiz - 3 Questions

Look at the execution table, what is the elapsed time when Tick 1 is printed?

A 300 ms

B 900 ms

C 600 ms

D 1200 ms

💡 Hint

Check the 'Elapsed Time (ms)' column at the row where Output is 'Tick 1'.

At which step does the timeout get exceeded causing the exception?

A Step 5

B Step 4

C Step 3

D Timeout never exceeded

💡 Hint

Look at the 'Timeout Check' column to find when it says 'Exceeded'.

If the timeout was increased to 1600 ms, how many ticks would print before timeout?

A 4 ticks

B 5 ticks

C 3 ticks

D No ticks

💡 Hint

Each tick takes about 300 ms delay; check variable_tracker elapsed times to estimate.

Concept Snapshot

withTimeout(timeMillis) runs a coroutine block with a time limit.
If the block exceeds timeMillis, it throws TimeoutCancellationException.
Use it to stop long-running tasks safely.
Inside, normal code runs until timeout or completion.
Exception cancels coroutine immediately.

Full Transcript

This example shows how Kotlin's withTimeout function works. The coroutine runs a block that repeats a delay and print action. Each delay is 300 milliseconds. The withTimeout is set to 1000 milliseconds. The execution table shows each step with elapsed time and output. At step 5, elapsed time exceeds 1000 ms, so withTimeout throws a TimeoutCancellationException and stops the coroutine. The variable tracker shows elapsed time increasing and tick count. Key moments clarify why execution stops early and how cancellation happens. The quiz tests understanding of timing and behavior. The snapshot summarizes the concept simply.

Practice

1. What does the Kotlin function withTimeout do?

easy

A. It cancels all running coroutines immediately.

B. It repeats a block of code until a timeout occurs.

C. It stops a block of code if it runs longer than the specified time.

D. It delays the execution of a block for a fixed time.

Solution

1. Step 1: Understand the purpose of withTimeout

   withTimeout is designed to stop a block of code if it exceeds a given time limit.

2. Step 2: Compare options with the definition

   Only "It stops a block of code if it runs longer than the specified time." correctly describes this behavior. Other options describe different coroutine behaviors.

3. Final Answer:

   It stops a block of code if it runs longer than the specified time. -> Option C

4. Quick Check:

   withTimeout stops code after time limit [OK]

Hint: Remember: withTimeout interrupts long-running code [OK]

Common Mistakes:

• Confusing withTimeout with delay function
• Thinking it repeats code instead of stopping
• Assuming it cancels all coroutines globally

2. Which of the following is the correct syntax to use withTimeout in Kotlin?

easy

A. withTimeout(1000) { /* code block */ }

B. withTimeout { 1000, /* code block */ }

C. withTimeout[1000] { /* code block */ }

D. withTimeout: 1000 { /* code block */ }

Solution

1. Step 1: Recall the function signature

   The correct syntax uses parentheses with the timeout in milliseconds as the first argument, followed by a lambda block.

2. Step 2: Match options with correct syntax

   withTimeout(1000) { /* code block */ } matches this pattern exactly. Others use incorrect brackets or misplaced arguments.

3. Final Answer:

   withTimeout(1000) { /* code block */ } -> Option A

4. Quick Check:

   withTimeout uses parentheses for timeout [OK]

Hint: Use parentheses with timeout value before code block [OK]

Common Mistakes:

• Using square brackets instead of parentheses
• Placing timeout inside the block instead of argument
• Using colon instead of parentheses

3. What will be the output of this Kotlin code?

import kotlinx.coroutines.*

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

medium

A. Processing 0
Processing 1
Processing 2
Processing 3
Processing 4

B. Processing 0
Processing 1
Timeout occurred

C. Timeout occurred

D. Processing 0
Timeout occurred
Processing 1

Solution

1. Step 1: Analyze the timing of the loop and timeout

   Each iteration delays 50ms. After two iterations, 100ms timeout is reached.

2. Step 2: Determine output before timeout

   "Processing 0" and "Processing 1" print before timeout triggers. Then exception is caught and "Timeout occurred" prints.

3. Final Answer:

   Processing 0 Processing 1 Timeout occurred -> Option B

4. Quick Check:

   Timeout stops after 2 prints + exception message [OK]

Hint: Multiply delay by iterations to compare with timeout [OK]

Common Mistakes:

• Assuming all iterations print before timeout
• Ignoring exception catch block
• Thinking timeout cancels immediately without partial output

4. Identify the error in this Kotlin code using withTimeout:

import kotlinx.coroutines.*

fun main() = runBlocking {
    withTimeout(100) {
        delay(200)
        println("Done")
    }
}

medium

A. TimeoutCancellationException is thrown because delay exceeds timeout.

B. Syntax error: withTimeout requires a try-catch block.

C. No error; code runs and prints "Done" after 200ms.

D. Delay function cannot be used inside withTimeout.

Solution

1. Step 1: Understand withTimeout behavior with delay

   The delay of 200ms exceeds the 100ms timeout, causing a TimeoutCancellationException.

2. Step 2: Check error handling

   No try-catch is present, so exception will be thrown and program will crash.

3. Final Answer:

   TimeoutCancellationException is thrown because delay exceeds timeout. -> Option A

4. Quick Check:

   Delay longer than timeout causes exception [OK]

Hint: Delay longer than timeout causes exception unless caught [OK]

Common Mistakes:

• Assuming code waits full delay then prints
• Thinking try-catch is mandatory syntax
• Believing delay can't be used inside withTimeout

5. You want to run a network request that should timeout after 500ms. Which Kotlin code correctly uses withTimeout to achieve this and handle timeout gracefully?

hard

A. try {
networkRequest()
withTimeout(500)
} catch (e: TimeoutCancellationException) {
println("Request timed out")
}

B. withTimeout(500) {
try {
networkRequest()
} catch (e: TimeoutCancellationException) {
println("Request timed out")
}
}

C. withTimeoutOrNull(500) {
networkRequest()
} ?: println("Request timed out")

D. try {
withTimeout(500) {
networkRequest()
}
} catch (e: TimeoutCancellationException) {
println("Request timed out")
}

Solution

1. Step 1: Understand correct placement of withTimeout and try-catch

   The timeout should wrap the networkRequest call, and the exception should be caught outside to handle timeout.

2. Step 2: Evaluate options for proper structure

   try { withTimeout(500) { networkRequest() } } catch (e: TimeoutCancellationException) { println("Request timed out") } correctly wraps networkRequest inside withTimeout and catches the exception outside. withTimeout(500) { try { networkRequest() } catch (e: TimeoutCancellationException) { println("Request timed out") } } catches inside, which won't catch timeout. withTimeoutOrNull(500) { networkRequest() } ?: println("Request timed out") uses withTimeoutOrNull (valid but different). try { networkRequest() withTimeout(500) } catch (e: TimeoutCancellationException) { println("Request timed out") } misplaces withTimeout after networkRequest.

3. Final Answer:

   try { withTimeout(500) { networkRequest() } } catch (e: TimeoutCancellationException) { println("Request timed out") } -> Option D

4. Quick Check:

   Wrap withTimeout around call, catch outside [OK]

Hint: Wrap withTimeout around call, catch exception outside [OK]

Common Mistakes:

• Catching exception inside withTimeout block
• Placing withTimeout after the call
• Confusing withTimeout with withTimeoutOrNull