Jaeeun1083
commented
5 months ago 지난 정리에서 launch()의 내부 동작을 확인하며 coroutine.start(start, coroutine, block)가 뭘 하는 건지 해결이 안된 채로 넘어갔었다.
간단하지만 그 의문에 대해 해결해보자.
CoroutineScope의 extension function - launch
// Builders.common.kt
public fun CoroutineScope.launch(
context: CoroutineContext = EmptyCoroutineContext,
start: CoroutineStart = CoroutineStart.DEFAULT,
block: suspend CoroutineScope.() -> Unit
): Job {
val newContext = newCoroutineContext(context)
val coroutine = if (start.isLazy)
LazyStandaloneCoroutine(newContext, block) else
StandaloneCoroutine(newContext, active = true)
coroutine.start(start, coroutine, block)
return coroutine
}
// jvmMain/CoroutineContext.kt
public actual fun CoroutineScope.newCoroutineContext(context: CoroutineContext): CoroutineContext {
val combined = coroutineContext + context
val debug = if (DEBUG) combined + CoroutineId(COROUTINE_ID.incrementAndGet()) else combined
return if (combined !== Dispatchers.Default && combined[ContinuationInterceptor] == null)
debug + Dispatchers.Default else debug
}
// Builders.common.kt
private open class StandaloneCoroutine(
parentContext: CoroutineContext,
active: Boolean
) : AbstractCoroutine<Unit>(parentContext, initParentJob = true, active = active) {
override fun handleJobException(exception: Throwable): Boolean {
handleCoroutineException(context, exception)
return true
}
}
// Builders.common.kt
public fun <R> start(start: CoroutineStart, receiver: R, block: suspend R.() -> T) {
start(block, receiver, this)
}coroutine.start(...) 이 부분만 보면 무한 반복 함수처럼 보일 수 있다.
그러나 CoroutineStart를 살펴보면, invoke 연산자 오버로딩이 되어 있어서 이 부분이 호출된다.
// CoroutineStart.kt
@InternalCoroutinesApi
public operator fun <R, T> invoke(block: suspend R.() -> T, receiver: R, completion: Continuation<T>): Unit =
when (this) {
DEFAULT -> block.startCoroutineCancellable(receiver, completion)
ATOMIC -> block.startCoroutine(receiver, completion)
UNDISPATCHED -> block.startCoroutineUndispatched(receiver, completion)
LAZY -> Unit // will start lazily
}이로 인해 해당 블록을 수신자(receiver)로 하여 이 코루틴 시작 전략(coroutine start strategy)으로 코루틴을 시작하게 되는 것이다.
[ invoke 함수란? ]
코루틴 시작 전략 중 DEFAULT에 해당하는 startCoroutineCancellable만 살펴보도록 하자.
// Cancellable.kt
@InternalCoroutinesApi
public fun <T> (suspend () -> T).startCoroutineCancellable(completion: Continuation<T>): Unit = runSafely(completion) {
createCoroutineUnintercepted(completion).intercepted().resumeCancellableWith(Result.success(Unit))
}
// IntrinsicsJVM.kt
@SinceKotlin("1.3")
public actual fun <T> (suspend () -> T).createCoroutineUnintercepted(
completion: Continuation<T>
): Continuation<Unit> {
val probeCompletion = probeCoroutineCreated(completion)
return if (this is BaseContinuationImpl)
create(probeCompletion)
else
createCoroutineFromSuspendFunction(probeCompletion) {
(this as Function1<Continuation<T>, Any?>).invoke(it)
}
}
// BaseContinuationImpl.kt
public open fun create(completion: Continuation<*>): Continuation<Unit> {
throw UnsupportedOperationException("create(Continuation) has not been overridden")
}
- probeCoroutineCreated은 코루틴이 생성될 때 디버그 용으로 호출하는 것이다.
- 서스펜딩 람다는 createCoroutineFromSuspendFunction를 거쳐 수행될 것이다. (?)
// IntrinsicsJVM.kt
@SinceKotlin("1.3")
private inline fun <T> createCoroutineFromSuspendFunction(
completion: Continuation<T>,
crossinline block: (Continuation<T>) -> Any?
): Continuation<Unit> {
val context = completion.context
// label == 0 when coroutine is not started yet (initially) or label == 1 when it was
return if (context === EmptyCoroutineContext)
object : RestrictedContinuationImpl(completion as Continuation<Any?>) {
private var label = 0
override fun invokeSuspend(result: Result<Any?>): Any? =
when (label) {
0 -> {
label = 1
result.getOrThrow() // Rethrow exception if trying to start with exception (will be caught by BaseContinuationImpl.resumeWith
block(this) // run the block, may return or suspend
}
1 -> {
label = 2
result.getOrThrow() // this is the result if the block had suspended
}
else -> error("This coroutine had already completed")
}
}
else
object : ContinuationImpl(completion as Continuation<Any?>, context) {
private var label = 0
override fun invokeSuspend(result: Result<Any?>): Any? =
when (label) {
0 -> {
label = 1
result.getOrThrow() // Rethrow exception if trying to start with exception (will be caught by BaseContinuationImpl.resumeWith
block(this) // run the block, may return or suspend
}
1 -> {
label = 2
result.getOrThrow() // this is the result if the block had suspended
}
else -> error("This coroutine had already completed")
}
}
}여기서 context의 EmptyCoroutineContext 여부에 따라 만드는 ContinuationImpl 객체가 달라지는데 launch()를 호출하면
맨 위에 나와있듯이 val newContext = newCoroutineContext(context)를 호출하여 Dispatcher.Default를 주입하므로 ContinuationImpl이 구현된다
다시 createCoroutineUnintercepted() 호출한 곳으로 돌아가서 나머지 부분을 확인해보자.
// Cancellable.kt
@InternalCoroutinesApi
public fun <T> (suspend () -> T).startCoroutineCancellable(completion: Continuation<T>): Unit = runSafely(completion) {
createCoroutineUnintercepted(completion).intercepted().resumeCancellableWith(Result.success(Unit))
}
public fun <T> Continuation<T>.resumeCancellableWith(result: Result<T>) = when (this) {
is DispatchedContinuation -> resumeCancellableWith(result)
else -> resumeWith(result)
}intercepted()는 launch에 디스패처를 설정하였다면 동작하게 된다.
이후resumeWith를 호출하며 launch의 내부 동작이 마무리된다.
정리
즉 launch()의 동작 과정을 다시 정리하자면
- launch() 호출 시 파라미터로 받은 context 객체를 newCoroutineContext() 호출을 통해 주어진 context와 현재 CoroutineScope의 context를 결합하여 새로운 CoroutineContext를 만든다.
- 생성한 context 를 사용하여 Coroutine 객체를 만든다.
- launch() 호출 시 파라미터로 받은 CoroutineStart 값에 따라 코루틴 시작 전략을 정하여 코루틴을 시작한다.
lee-ji-hoon
Jwhyee
3월 31일 11, 12, 13장