[Coroutine] 코루틴 스코프 함수

 💡 코루틴의 생명 주기를 제어하는 데 도움을 주는 코루틴 스코프 함수에 대하여 학습하였습니다.

코루틴 스코프

코루틴 스코프의 필요성

• 아래 작업은 중단 함수에서 중단 함수를 호출하며, 작업이 동시에 진행되지 않는다는 문제가 있습니다.
  • 하나의 앤드포인트에서 데이터를 얻는 데 1초씩 걸리므로 총 2초 소모

suspend fun getUserProfile() : UserProfileData {
    val user = getUserData() // 1초 후 
    val notifications = getNotifications() // 1초 후

    return UserProfileData(
        user = user,
        notifications = notifications,
    )
}

• 두 중단 함수를 동시에 실행하려면 각 함수를 async로 래핑해야 합니다.
• 하지만 async는 스코프를 필요로 하며 GlobalScope를 사용하는 건 좋은 방법이 아닐 수 있습니다.
  • 이는 EmptyCorotineContext를 가진 스코프일 뿐이며, async를 호출하면 부모 코루틴과 아무런 관계가 없습니다.

async의 단점

• 취소가 어려움
  • 부모가 취소되어도 async 내부의 함수가 실행 중인 상태가 되므로 작업이 끝날 때까지 자원이 낭비됩니다.
• 부모로부터 스코프를 상속받지 않음
  • 항상 기본 디스패처에서 실행되며, 부모의 컨텍스트를 신경쓰지 않습니다.
• 이는 메모리 누수가 발생할 수 있으며 CPU를 낭비합니다.
• 코루틴을 단위 테스트하는 도구가 작동하지 않아 함수를 테스트하기 어렵습니다.
• cancel 메서드를 사용해 스코프를 취소하는 등의 방법으로 조작이 가능하지만, 다루기 어려우면서 잠재적으로 위험할 수 있습니다.

coroutineScope

• coroutineScope는 스코프를 시작하는 중단 함수이며, 인자로 들어온 함수가 생성한 값을 반환합니다.

suspend fun <R> coroutineScope(
    block: suspend CoroutineScope.() -> R
): R

• async나 launch와 다르게 coroutineScope의 본체는 리시버 없이 곧바로 호출됩니다.
• coroutineScope는 새로운 코루틴을 생성하지만 새로운 코루틴이 끝날 때까지 coroutineScope를 호출한 코루틴을 중단하기 때문에, 호출한 코루틴이 작업을 동시에 시작하지는 않습니다.

fun main() = runBlocking {
    coroutineScope {
        delay(1000)
        print(10)
    }
    coroutineScope {
        delay(1000)
        prlint(20)
    }
}

// 1초 후 
// 10
// 1초 후
// 20

coroutineScope의 특징

• 위 코드에서 생성된 스코프는 바깥의 스코프에서 coroutineContext를 상속받지만 컨텍스트의 Job을 오버라이딩하여 부모의 책임을 이어받습니다.
  • 부모로부터 컨텍스트 상속
  • 자신의 작업이 끝내기 전까지 모든 자식을 기다림
  • 부모가 취소되면 자식들 모두 취소
• 아래와 같은 coroutineScope 함수가 있다고 가정합니다.

suspend fun longTask() = coroutineScope {
    launch {
        delay(1000)
        val name = coroutineContext[CoroutineName]?.name
        println("[$name] Finished task 1")
    }
    launch {
        delay(2000)
        val name = coroutineContext[CoroutineName]?.name
        println("[$name] Finished task 2")
    }}

• 모든 자식을 기다리는 특성

fun main() = runBlocking(CoroutineName("Parent")) {
    println("Before")
    longTask()
    println("After")
}
// Before
// 1초 후
// [Parent] Finished task 1
// 1초 후
// [Parent] Finished task 2
// After

• 부모가 취소되면 자식들 모두 취소되는 특성

fun main(): Unit = runBlocking {
    val job = launch(CoroutineName("Parent")) {
        longTask()
    }
    delay(1500)
    job.cancel()
}
// [Parent] Finished task 1

coroutineScope의 예외처리

• 코루틴 빌더와 달리 coroutineScope나 스코프에 속한 자식에서 예외가 발생하면 다른 모든 자식이 취소되고 예외가 다시 던져집니다.
  • 이를 구조적 동시성을 보장한다고 합니다.
  • 코루틴 빌더인 launch는 예외가 부모로 전파됩니다.
  • 코루틴 빌더인 async는 예외가 Deferred 객체에 저장되며, await() 호출 시 예외가 던져집니다.
  • 코루틴 빌더는 다른 코루틴은 계속 실행됩니다.

class ApiEcception(
    val code: Int,
    message: String,
): Throwable(message)

fun getFollowersNumber(): Int
suspend fun getUserName(): String

suspend fun getTweets(): List<Tweet>

suspend fun getUserDetails(): Details = coroutineScope{
    val userName = async { getUserName() }
    val followersNumber = async { getFollowersNumber()}
    Detail(userName.await() , followersNumber.await())
}

fun main() = runBlocking<Unit> {
    val details = try {
        getUserDetails()
    } catch (e: ApiException) {
        null
    }
    val tweets = async { getTeets() }
    println("User: $details")
    println("Tweets: ${tweets.await()}")
}
// User: null
// Tweets: [Tweet(text=Hellow, world)]

• 중단 함수에서 병렬로 작업을 수행할 경우 coroutineScope를 활용하는 것이 좋습니다.

coroutineScope 활용

• coroutineScope는 중단 메인 함수 본체를 래핑할 때 주로 사용됩니다.
• runBlocking 함수를 coroutineScope가 대체할 수 있습니다.

suspend fun main(): Unit = coroutineScope {
    launch {
        delay(1000)
        println("World")
    }
    println("Hello, ")
}

• coroutineScope 함수는 기존의 중단 컨텍스트에서 벗어난 새로운 스코프를 만들며, 부모로부터 스코프를 상속받고 구조화된 동시성을 지원합니다.

코루틴 스코프 함수

• 스코프를 생성하는 다양한 함수가 있으며, coroutineScope와 비슷하게 동작합니다.
• 코루틴 스코프 함수는 코루틴 빌더와 혼동되지만, 두 함수는 개념적으로나 사용함에 있어서 다르기 때문에 쉽게 구분할 수 있습니다.

코루틴 빌더(runBlocking을 제외한)코루틴 스코프 함수

launch, async, produce	coroutineScope, supervisorScope, withContext, withTimeout
CoroutineScope의 확장 함수	중단 함수
CoroutineScope 리시버의 코루틴 컨텍스트를 사용	중단 함수의 컨티뉴에이션 객체가 가진 코루틴 컨텍스트를 사용
예외는 Job을 통해 부모로 전파	일반 함수와 같은 방식으로 예외 처리
비동기인 코루틴을 시작	코루틴 빌더가 호출된 곳에서 코루틴 시작

• runBlocking을 제외한 이유는 runBlocking은 코루틴 빌더보다 코루틴 스코프 함수와 비슷한 점이 더많아보이기 때문입니다.
• runBlocking 또한 함수 본체를 곧바로 호출하고 그 결과를 반환하며, runBlocking은 블로킹 함수지만 코루틴 스코프 함수는 중단 함수라는 점입니다.
• 따라서 runBlocking은 코루틴 계층에서 가장 상위에 있으며, 코루틴 스코프 함수는 중간 계층에 존재합니다.

withContext

• withContext는 coroutineScope와 비슷하지만 스코프의 컨텍스트를 변경할 수 있다는 특징을 가지고 있습니다.
• withContext의 인자로 컨텍스트를 제공하면 코루틴 빌더와 같은 방식으로 부모 스코프의 컨텍스트를 대체합니다.

withContext(CoroutineName("Child 1")) {
    delay(1000)
    log("Child 1")
}

• 주로 기존 스코프와 컨텍스트가 다른 코루틴 스코프를 설정하기 위해 사용합니다.

launch(Dispatchers.Main) {
    view.showProgressBar()
    withContext(Dispathcers.IO){
        filePepository.saveData(data)
    }
    view.hidePrgoressBar()
}

supervisorScope

• supervisorScope는 호출한 스코프로부터 상속받은 coroutineScope를 만들고 지정된 중단 함수를 호출한다는 점에서 coroutineScope와 비슷합니다.
• 둘의 차이는 컨텍스트의 Job을 SupervisorJob으로 오버라이딩하는 것이기 때문에 자식 코루틴이 예외를 던지더라도 취소되지 않습니다.

fun main() = runBlocking {
    println("Before")

    supervisorScope {
        launch {
            delay(100)
            throw Error()
        }

        launch {
            delay(2000)
            println("Done")
        }
    }

    println("After")
}
// Before
// 1초 후
// 예외 발생
// 1초 후
// Done
// After

• supervisorScope는 서로 독립적인 작업을 시작하는 함수에서 주로 사용됩니다.

suspend fun notifyAnalytics(actions: List<UserAction>) =
    supervisorScope {
        actions.forEach { action ->
            launch {
                notifyAnalytics(action)
            }
        }
    }

• async와 함께 사용
  • async를 사용하면 예외가 부모로 전파되는 걸 막기 위한 추가적인 예외 처리가 필요합니다.
  • await를 호출하고 async 코루틴이 예외로 끝나게 된다면 await는 예외를 다시 던지기 됩니다.
  • 따라서 async에서 발생하는 예외를 전부 처리하려면 try-catch 블록으로 await 호출을 래핑해야 합니다.

// async를 활용한 경우
superviorScope {
    articleRepositories
        .map { async { it.fetchArticles() } }
        .mapNotNull {
            try {
                it.await()
            } catch (e: Throwable) {
                e.printStackTrace()
                null
            }
        }
}

• withContext(SupervisorJob())을 쓰면 안되는 이유
  • supervisorScope 대신 withContext(SupervisorJob())을 활용할 경우 잘못 된 코드가 될 수 있습니다.
  • withContext는 여전히 기존에 가지고 있던 Job을 사용하며 SupervisorJob()이 해당 잡의 부모가 됩니다.
  • 따라서 하나의 자식 코루틴이 예외를 던진다면 다른 자식들 또한 취소가 됩니다.
  • 결국 SupervisorJob()이 필요가 없어지며, withContext 또한 예외를 던집니다.

withTimeout

• coroutineScope와 비슷한 함수이며, 스코프를 만들고 값을 반환합니다.
• 인자로 들어온 람다식을 실행할 때 시간 제한이 있으며, 시간이 너무 오래 걸리면 람다식을 취소하고 TimeoutCancellationException을 던집니다.
  • 이 때 TimeoutCancellationException은 CancellationException의 서브타입입니다.

suspend fun test(): Int = withTimeout(1500){
    delay(1000)
    println("Still thinking")
    delay(1000)
    prntln("Done!")
    42
}
// 1 초 후
// Still thinking
// 0.5초 후
// TimeoutCancellationException

• 이는 테스트할 때 유용하며, 특정 함수가 시간이 얼마나 걸리는지 확인하는 용도로도 사용할 수 있습니다.
• runTest 내부에서 사용한다면, withTimeout은 가상 시간으로 작동하게 됩니다.

코루틴 스코프 함수 연결하기

suspend fun calcuateAnswerOrNull(): User? =
    withContext(Dispatchers.Default) {
        withTimeoutOrNull(1000){
            calcuateAnswer()
        }
    }

• 서로 다른 코루틴 스코프 함수의 두 가지 기능이 모두 필요하다면 코루틴 스코프 함수에서 다른 기능을 가지는 코루틴 스코프 함수를 호출할 수 있습니다.

추가적인 연산

• 작업을 수행하는 도중에 추가적인 연산을 수행해야하는 경우가 있습니다.

suspend fun showUserData() = coroutineScope {
    val user = User(
        name = name.await(), // async
        profile = profie.await() // async
    )
    view.show(user)
    launch {
        repo.notifyProfileShown()
    }
}

fun onCreate(){
    viewModelScope.launch {
        _progressBar.value = true
        showUserData()
        _progressBar.value = false
    }
}

• 이 방식에는 아래와 같은 문제점이 있습니다.
• [ 함수의 목적을 벗어난 지나친 기다림 ]
  • coroutineScope가 사용자 데이터를 로드하고 보여준 후 notifyProfileShown()를 실행하므로, 사용자의 데이터를 로드할 때 나타낼 _progressBar는 notifyProfileShown()가 종료될 때까지 보여집니다.
  • 이런 경우 showUserData() 함수로부터 기대하는 유의미한 작업을 한다고 보기 어렵습니다.
• [ 취소 ]
  • 코루틴은 예외가 발생했을 때 다른 연산을 취소하게 되어있습니다.
  • notifyProfileShown()이 profie.await()에 의해 취소된다면 전체 과정이 취소될 수 있습니다.
  • 이 때 핵심 동작에 영향을 주지 않는 추가적인 연산이 있는 경우 ( 위에서는 notifyProfileShown()) 다른 스코프에서 시작하는 편이 낫습니다.
  • 이 때 가장 쉬운 방법은 연산을 위한 스코프를 생성하는 것입니다.

val analyticsScope = CoroutineScope(SupervisorJob())

• 이를 활용해서 위 코드를 아래처럼 수정할 수 있습니다.

class ShowUserDataUseCase(
    ...
    private val analyticsScope: CorotineScope,
){
    suspend fun showUserData() = coroutineScope {
        val user = User(
            name = name.await(), // async
            profile = profie.await() // async
        )
        view.show(user)
        analyticsScope.launch {
            repo.notifyProfileShown()
        }
    }
}

• 네이밍 된 스코프를 전달함으로써 독립적인 작업을 실행한다는 것을 명확하게 알릴 수 있습니다.
• 따라서 중단 함수는 주입된 스코프에서 시작한 연산이 끝날 때까지 기다리지 않습니다.
• 스코프가 전달되지 않으면 중단 함수는 모든 연산이 완료될 때까지 종료되지 않을 거라는 걸 예상할 수 있습니다.