In‑Depth Source Code Analysis of Kotlin Coroutines: Launch, Suspension, and Resumption

Kotlin coroutines became stable starting with Kotlin 1.3, offering a more convenient way to perform asynchronous calls compared with Java Executor or RxJava. The article analyzes coroutines from a source‑code perspective, covering their essence, launch process, suspension, and how they eliminate callback hell.

Creating a coroutine is done via GlobalScope.launch(Dispatchers.Default) { /* coroutine body */ } . The launch call builds a CoroutineScope and a Job , then starts the coroutine using CoroutineStart.DEFAULT .

During compilation the coroutine body (a suspend lambda) is turned into a class that extends SuspendLambda , which itself inherits from ContinuationImpl → BaseContinuationImpl → Continuation . The generated class contains a label field that represents the state machine and implements invokeSuspend where the actual logic resides.

The core interfaces involved are:

Continuation : defines context and resumeWith .

BaseContinuationImpl : abstract class that overrides resumeWith and declares abstract invokeSuspend .

CoroutineDispatcher : abstract dispatcher that implements ContinuationInterceptor and provides dispatch and isDispatchNeeded .

DispatchedContinuation : wraps the original continuation, holds a dispatcher , and implements resumeWith to either dispatch the continuation to a thread pool or execute it directly.

CoroutineScheduler and its Worker threads form the thread‑pool that actually runs dispatched continuations.

The launch implementation creates a StandaloneCoroutine , merges the provided CoroutineContext with the scope’s context, and calls start . CoroutineStart.invoke eventually calls block.startCoroutineCancellable , which creates an un‑intercepted coroutine instance, intercepts it with the dispatcher (producing a DispatchedContinuation ), and resumes it via resumeCancellableWith .

Suspension occurs inside invokeSuspend . When a suspend function returns coroutine_suspended , invokeSuspend returns this marker, causing resumeWith to exit. The state machine’s label records the next resume point.

The withContext suspend function creates a new DispatchedCoroutine (a subclass of AbstractCoroutine ) that holds the outer continuation. It starts the inner block with startCoroutineCancellable . The inner coroutine may suspend; when it completes, DispatchedCoroutine.afterResume checks whether it was suspended. If so, it resumes the outer continuation via uCont.intercepted().resumeCancellableWith , effectively switching back to the original thread/context.

Performance measurements show that launching 100 000 coroutines and printing a value takes far less memory than creating the same number of Java Thread objects, which typically leads to OOM errors.

In summary, the article demystifies Kotlin coroutine internals: the transformation of suspend lambdas into state‑machine classes, the role of Continuation hierarchy, dispatchers, the scheduler, and how suspension and resumption are orchestrated without blocking threads.