launch — essence, fire-and-forget coroutine launch and how it works

What is launch in Kotlin Coroutines?

launch is a Kotlin extension function, available through the kotlinx.coroutines import, that creates a new coroutine in a given CoroutineScope. Unlike regular functions, code inside launch executes concurrently — the coroutine can suspend without blocking a thread and resume later.

The launch builder is a fundamental building block of the Kotlin coroutine model. It does not return a computed value but returns a Job object that allows controlling the coroutine execution. All child coroutines launched via launch inside another coroutine are bound to the parent.

Syntax and parameters of launch

The launch builder is defined as an inline function with several parameters: CoroutineScope, CoroutineContext, CoroutineStart, and a suspend block. The parameters have default values, making launch convenient for typical scenarios.

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job

The context parameter accepts a CoroutineContext that combines a dispatcher, exception handler, and a named element. Most often Dispatchers.IO, Dispatchers.Main, or SupervisorJob are passed for error isolation.

Job and lifecycle management

Job — the returned object representing the coroutine lifecycle. A Job can be in states: New, Active, Completing, Completed, Cancelling, Cancelled. Each state reflects the execution status and allows reacting to changes.

val job = CoroutineScope(Dispatchers.IO).launch {
    repeat(10) { i ->
        delay(1000L)
        println("Progress: $i")
    }
}

println("Job is active: ${job.isActive}")
delay(2500L)
job.cancel()
println("Job is cancelled: ${job.isCancelled}")

Job supports a hierarchy: if a parent coroutine is cancelled, all children are automatically cancelled. SupervisorJob changes this behavior — child coroutines are not cancelled when one of them fails.

Structured concurrency in launch

Structured concurrency means that each coroutine is launched within a specific CoroutineScope, and the scope will not complete until all child coroutines finish their work. launch fully supports this principle — coroutines launched inside another coroutine are its children.

Nested launch calls

With nested launch calls, a coroutine tree is formed. The parent coroutine waits for all children to complete, ensuring predictable execution order and simplifying resource management.

fun main() = runBlocking {
    launch {
        launch {
            delay(1000L)
            println("Child 1 completed")
        }
        launch {
            delay(500L)
            println("Child 2 completed")
        }
        println("All children complete before this line")
    }
}

This behavior differs from thread-based concurrency, where child threads are not bound to the parent. In coroutines, the parent does not complete until all children finish their work.

Exception handling in launch

Exception handling in launch depends on the type of Job. For a regular Job, exceptions propagate to the parent coroutine and cancel it. For SupervisorJob or SupervisorScope, exceptions are isolated — an error in one child coroutine does not affect the others.

val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
scope.launch {
    try {
        riskyOperation()
    } catch (e: Exception) {
        println("Caught: ${e.message}")
    }
}
scope.launch {
    println("This still runs thanks to SupervisorJob")
}

For global handling of uncaught exceptions, CoroutineExceptionHandler is used. It catches exceptions that were not handled inside the coroutine and allows logging the error without crashing the application.

Usage examples of launch in Android

In Android, launch is used everywhere: from ViewModel to WorkManager. The main pattern is using lifecycleScope in Fragment and viewModelScope in ViewModel for automatic coroutine cancellation when the component lifecycle ends.

class ProfileViewModel : ViewModel() {
    private val repository = UserRepository()

    fun loadProfile(userId: String) {
        viewModelScope.launch(Dispatchers.IO) {
            val profile = repository.fetchProfile(userId)
            withContext(Dispatchers.Main) {
                _profileState.update { it.copy(profile = profile) }
            }
        }
    }
}

viewModelScope automatically cancels coroutines when the ViewModel is destroyed. This eliminates leaks and ensures that background operations do not continue after losing context. Additionally, withContext can be used to switch between dispatchers.