Launch coroutine builder in Kotlin - Step-by-Step Execution

Concept Flow - Launch coroutine builder

Start main function

↓

Call launch builder

↓

Coroutine starts

↓

Execute coroutine code

↓

Coroutine completes

↓

Main continues or waits

↓

Program ends

The launch builder starts a coroutine that runs concurrently, allowing main to continue or wait for completion.

Execution Sample

Kotlin

fun main() = runBlocking {
    launch {
        println("Hello from coroutine")
    }
    println("Hello from main")
}

Starts a coroutine that prints a message while main also prints its own message.

Execution Table

Step	Action	Evaluation	Output
1	Enter runBlocking scope	runBlocking starts main coroutine
2	Call launch builder	New coroutine starts concurrently
3	Main prints message	Prints inside main coroutine	Hello from main
4	Coroutine prints message	Prints inside coroutine	Hello from coroutine
5	runBlocking waits for launch coroutine	Coroutine completes
6	Program ends	All coroutines done

💡 All coroutines complete, runBlocking scope ends, program terminates

Variable Tracker

Variable	Start	After launch	After coroutine print	After main print	Final
Coroutine State	Not started	Started	Running	Completed	Completed
Main State	Running	Running	Running	Running	Completed

Key Moments - 2 Insights

Why does "Hello from main" sometimes print before "Hello from coroutine"?

Because launch starts a new coroutine concurrently, main continues immediately (see execution_table step 3 before step 4 finishes).

Does launch block the main thread until coroutine finishes?

No, launch starts coroutine asynchronously; runBlocking waits for all coroutines before ending (see execution_table step 5).

Visual Quiz - 3 Questions

Look at the execution_table, at which step does the coroutine print its message?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Check the Output column for the coroutine's print message.

According to variable_tracker, what is the Coroutine State after launch is called?

A Started

B Not started

C Running

D Completed

💡 Hint

Look at the 'After launch' column for Coroutine State.

If we remove runBlocking, what would happen to the coroutine's output?

A It will always print before main

B It might not print at all before program ends

C It will block main until done

D It will print twice

💡 Hint

Without runBlocking, main may finish before coroutine runs (see concept_flow).

Concept Snapshot

launch { ... } starts a new coroutine concurrently.
It runs code asynchronously without blocking main.
Use runBlocking to wait for coroutine completion.
Output order may vary due to concurrency.
launch returns immediately, coroutine runs in background.

Full Transcript

This example shows how the launch coroutine builder starts a new coroutine inside a runBlocking scope. The launch coroutine runs concurrently with the main coroutine. The main coroutine continues immediately after launch is called, printing its message. The launched coroutine prints its message asynchronously. The runBlocking scope waits for all coroutines to finish before ending the program. Variables track coroutine and main states from start to completion. Key points include understanding concurrency and that launch does not block main. The visual quiz tests understanding of execution steps and coroutine states.