Kotlin 2 min read

Kotlin Coroutine Builders Tutorial: launch, async, withContext, and runBlocking Explained with Examples

This Kotlin Coroutine Builders tutorial explains how to use launch, async, withContext, and runBlocking to manage asynchronous tasks efficiently. The chapter focuses on practical examples, structured concurrency, and best practices to help developers write clean, non-blocking, and maintainable Kotlin code.

Coroutine Builders in Kotlin (Complete Tutorial)

Coroutine Builders Overview

Coroutine builders are functions that start new coroutines. Each builder serves a specific purpose depending on whether you need a return value, thread switching, or blocking behavior.

launch

launch starts a new coroutine that does not return a result. It returns a Job.

Use Case

  1. Fire-and-forget tasks
  2. Background operations
  3. UI updates

Example


import kotlinx.coroutines.*

fun main() = runBlocking {
val job = launch {
delay(1000L)
println("Task completed")
}
job.join()
println("Main continues")
}

Best Practices

  1. Use launch when you don’t need a result.
  2. Always manage the Job lifecycle.

async

async starts a coroutine that returns a result using Deferred<T>.

Use Case

  1. Parallel computations
  2. When a result is required

Example


import kotlinx.coroutines.*

fun main() = runBlocking {
val deferred = async {
delay(1000L)
10 + 20
}
println("Result: ${deferred.await()}")
}

Best Practices

  1. Always call await() to get the result.
  2. Use async inside a structured scope.

launch vs async

Featurelaunchasync
Returns valueNoYes
Return typeJobDeferred<T>
Use caseBackground tasksParallel tasks

withContext

withContext switches the coroutine context without creating a new coroutine.

Use Case

  1. Switching threads
  2. Performing I/O or CPU tasks safely

Example


import kotlinx.coroutines.*

fun main() = runBlocking {
val result = withContext(Dispatchers.IO) {
delay(500L)
"Data loaded"
}
println(result)
}

Best Practices

  1. Prefer withContext over nested launch.
  2. Use for context switching only.

runBlocking

runBlocking blocks the current thread until execution completes.

Use Case

  1. Main functions
  2. Testing
  3. Learning and demos

Example


import kotlinx.coroutines.*

fun main() = runBlocking {
launch {
delay(500L)
println("Inside coroutine")
}
println("runBlocking active")
}

Best Practices

  1. Avoid runBlocking in production code.
  2. Never use it in Android UI threads.

Real-World Example: Parallel API Calls


import kotlinx.coroutines.*

suspend fun fetchUser(): String {
delay(1000L)
return "User"
}

suspend fun fetchOrders(): String {
delay(1000L)
return "Orders"
}

fun main() = runBlocking {
val user = async { fetchUser() }
val orders = async { fetchOrders() }

println("${user.await()} with ${orders.await()}")
}

Summary

This chapter covered Kotlin coroutine builders including launch, async, withContext, and runBlocking. Understanding when and how to use each builder is essential for writing efficient, concurrent, and structured Kotlin applications.