[Coroutine] 코루틴 빌더

 💡 코루틴 라이브러리를 활용하는 kotlin.coroutines에서 사용하는 다양한 코루틴 빌더에 대하여 학습하였습니다.

코루틴 빌더

• 중단 함수는 컨티뉴에이션 객체를 다른 함수로 전달해야 합니다.
  • 즉 중단 함수 → 일반 함수 호출은 가능하지만, 일반 함수 → 중단 함수 호출은 불가능합니다.
• 모든 중단 함수는 또 다른 중단 함수에 의해 호출되어야 하며, 이는 앞서 호출한 중단 함수 또한 마찬가지입니다.
• 중단 함수를 연속으로 호출하면 시작되는 지점이 반드시 있습니다.
• 코루틴 빌더(coroutine builder)가 그 역할을 하며, 일반 함수와 중단 가능한 세계를 연결시키는 다리 역할을 합니다.
  • launch
  • runBlocking
  • async

launch 빌더

• launch는 thread 함수를 호출하여 새로운 스레드를 시작하는 것과 비슷하며, 불꽃놀이를 할 때 불꽃이 하늘 위로 각자 퍼지는 것처럼 별개로 실행됩니다.

fun main() {
    GlobalScope.launch {
        delay(1000L)
        println("launch!")
    }
    GlobalScope.launch {
        delay(1000L)
        println("launch!")
    }
    GlobalScope.launch {
        delay(1000L)
        println("launch!")
    }
    println("load")
    Thread.sleep(2000L)
}
//load
// 1000L(1초) 후..
//launch!
//launch!
//launch!

• 위 방식은 안드로이드나 백엔드 애플리케이션 방식에서 좋은 방식이 아니지만, 코루틴 빌더에 의해 시작되는 것을 볼 수 있는 예시입니다.
  • 실제 협업에서는 GlobalScope의 사용을 지양해야 합니다.
• 코틀린 언어가 빌더를 자동으로 생성해주는 것을 알 수 있습니다.
• Thread.sleep(2000L)을 준 이유는 아래와 같습니다.
  • 스레드를 잠들게 하지 않으면 메인 함수는 코루틴을 실행하자마자 끝나버리며, 코루틴이 일을 할 기회를 주지 않습니다.
  • delay(1000L)은 스레드를 블록시키지 않고, 코루틴을 블록시킵니다.

CoroutineScope

• launch 함수는 CoroutineScope 인터페이스의 확장 함수입니다.
• CoroutineScope 인터페이스는 부모 코루틴과 자식 코루틴 사이의 관계 정립을 위한 목적으로 사용됩니다.
• 구조화된 동시성(structued concurrency)을 가지게 됩니다.
  • 동시성 프로그래밍을 더 안전하고 관리하기 쉽게 만드는 디자인 패턴
  • 프로그래밍 수명 주기를 관리하고, 예측 가능한 방식으로 동시성을 다룸
  • 구조화된 동시성을 사용하면 위 코드의 Thred.sleep 없이 동작할 수 있음

launch가 작동하는 방식

• 이는 데몬 스레드와 어느 정도 비슷하지만 훨씬 가볍습니다.
  • 데몬 스레드 : 백그라운드에서 돌아가며, 우선순위가 낮은 스레드
• 블로킹된 스레드를 유지하는 것은 비용이 들지만, 중단된 코루틴을 유지하는 것은 가볍습니다.
• 둘 다 별개의 작업을 시작하며 작업하는 동안 프로그램이 끝나는 걸 막을 수 있습니다.

runBlocking 빌더

• 코투틴이 스레드를 블로킹하지 않고 작업을 중단시키기만 하는 것이 일반적이지만, 블로킹이 필요한 경우가 있습니다.
• 메인 함수의 경우 프로그램을 너무 빨리 끝내지 않기 위해 스레드를 블로킹해야 합니다.
• 이 때 runBlocking을 사용할 수 있습니다.
• 새로운 코루틴을 실행한 뒤 완료될 때까지 현재 스레드를 중단 가능한 상태로 블로킹합니다.

runBlocking 동작 방식

• runBloking 내부에서 delay(1000L)을 호출하면 Thread.sleep(1000L)과 비슷하게 동작합니다.

fun main() {
    runBlocking {
        delay(1000L)
        println("load")
    }
    runBlocking {
        delay(1000L)
        println("load")
    }
    println("end")
}
// (1초 후_)
// load
// (1초 후_)
// load
// end

fun main() {
    Thread.sleep(1000L)
    println("load")
    Thread.sleep(1000L)
    println("load")
    println("end")
}
// (1초 후_)
// load
// (1초 후_)
// load
// end

runBlocking이 필요한 경우

• 프로그램이 끝나는 걸 방지하기 위해 스레드를 블로킹할 필요가 있는 메인 함수
• 스레드를 블로킹할 필요가 있는 유닛 테스트

async 빌더

• async 빌더는 launch와 비슷하지만 값을 생성하도록 설계되어 있습니다.
• 람다 표현식에 의해 반환되어야 하며 Deferred<T> 타입의 객체를 리턴하며, 값을 반환하는 중단 메서드인 await가 있습니다.

async 빌더의 특징

• launch 빌더와 비슷하며, 호출되자마자 코루틴을 시작합니다.
• 몇 개의 작업을 한번에 시작하고 모든 결과를 한꺼번에 기다릴 때 사용합니다.
• Deferred는 값이 생성되면 해당 값을 내부에 저장하기 때문에 await에서 값이 반환되는 즉시 값을 사용할 수 있습니다.
• 값이 생성되기 전에 await를 호출할 경우 값이 나올 때까지 기다리게 됩니다.

fun main() = runBlocking {
    val res1 = GlobalScope.async {
        delay(1000L)
        "Text 1"
    }
    val res1 = GlobalScope.async {
        delay(3000L)
        "Text 2"
    }
    val res1 = GlobalScope.async {
        delay(2000L)
        "Text 3"
    }
    println(res1.await())
    println(res2.await())
    println(res3.await())
    // (1초 후)
    // Text1
    // (2초 후)
    // Text2
    // Text3
}

• async 빌더는 launch와 작동하는 방식을 비슷하지만, 값이 필요한 경우만 활용해야 합니다.
• 또한 두 가지 다른 곳에서 데이터를 얻어와 합치는 경우처럼, 병렬로 실행할 때 주로 활용한다는 특징이 있습니다.

scope.launch {
    val news = async {
        newsRepo.getNews()
            .sortedByDescending { it.date }
    }
    val newsSummary = newsRepo.getNewsSummary()
    view.showNews(
        newsSummary,
        news.await()
}

구조화된 동시성

• 코루틴이 GlobalScope에서 시작되었다면 프로그램은 해당 코루틴을 기다리지 않습니다.
• 코루틴은 어떤 스레드도 블록하지 않기 때문에 프로그램이 끝나는 걸 막을 방법이 없습니다.

fun main() = runBlocking {
    GlobalScope.launch {
        delay(1000L)
        println("World!")
    }
    GlobalScope.launch {
        delay(2000L)
        println("World!")
    }
    println("Hello,")
}
// Hello,

• launch와 async는 CoroutineScope의 확장함수이기 때문에, GlobalScope를 사용해야 합니다.
• block 파라미터가 리시버 타입이 CoroutineScope인 함수형 타입이기 때문입니다.
• 하지만 아래 예시를 보면 대체할 방법이 있습니다.

fun <T> runBlocking(
    context: CoroutineContext = EmptyCoroutineContext,
    block: suspend CoroutineScope.() -> T
): T

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

fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Deferred<T>

• 모든 코루틴 빌더가 CoroutineScope를 리시버로 받는 것을 확인할 수 있으며, 이 이유로 GlobalScope를 굳이 사용하지 않고 this.launch를 통해서 같은 기능을 할 수 있습니다.
  • 이 기능을 통해서 launch는 runBlocking의 자식이 됩니다.
  • 부모가 자식을 기다리므로, runBlocking은 자식의 모든 작업이 끝날 때까지 기다립니다.

fun main() = runBlocking {
    this.launch {
        delay(1000L)
        println("World!")
    }
    println("Hello,")
}
// Hello,
// (1초 후)
// World!

• 부모는 자식들을 위한 스코프를 제공하고 자식들은 해당 스코프 내에서 호출합니다.
• 이를 구조화된 동시성이라는 관계라고 합니다.

구조화된 동시성의 특징

• 자식은 부모 컨텍스트를 상속받습니다.
  • 자식이 부모 컨텍스트를 재정의할 수 있습니다.
• 부모는 모든 자식이 작업을 마칠 때까지 기다립니다
• 부모 코루틴이 취소되면 자식도 취소됩니다.
• 자식 코루틴에서 에러가 발생하면 부모 코루틴도 에러로 소멸합니다.

runBlocking은?

• 코루틴 빌더 중에 runBlocking은 CoroutineScope의 확장함수가 아닙니다.
• 이는 runBlocking은 자식이 될 수 없으며, 루트 코루틴으로만 활용한다는 것을 의미합니다.
  • 계층상 모든 자식의 부모가 됩니다.

현업에서의 코루틴 사용

• 중단 함수는 다른 중단 함수들로부터 호출되어야 하며, 모든 중단 함수는 코루틴 빌더로 시작되어야 합니다.
  • 또한 runBlocking을 제외한 모든 코루틴 빌더는 CoroutineScope에서 시작되어야 합니다.
• 중단 함수 내부에서 중단될 수 있지만 함수 내에는 스코프가 없습니다.
• 스코프를 인자로 넘기는 건 좋은 방법이라 할 수 없으며, 코루틴 빌더가 사용할 스코프를 만들어주는 중단 함수인 coroutineScope 함수를 사용할 수 습니다.

scope를 제공하는 방법

• runBlocking 활용
• 직접 코루틴 스코프 제작
• 프레임워크에서 제공하는 스코프 사용
  • 백엔드 : Ktor
  • 안드로이드 : Android KTX

coroutineScope 사용하기

• 아래의 예시처럼 비동기적으로 두 개의 자원이 필요한 경우가 있습니다.
  • 사용자 데이터
  • 글 목록

suspend fun getArticlesForUser(
    userToken: String?,
): List<ArticleJson> = coroutineScope {
    val articles = async { articleRepository.getArticles() }
    val user = userService.getUser(userToken)
    articles.await()
        .filter { canSeeOnList(user, it) }
        .map { toArticleJson(it) }
}

• coroutineScope는 람다 표현식이 필요로 하는 스코프를 만들어 주는 중담 함수 입니다.
• let, run, use 또는 runBlocking 처럼 람다식이 반환하는 것이면 무엇이든 반환합니다.
• 중단 함수 밖에서 스코프를 만들려면 coroutineScope를 사용해야 하며, runBlocking을 활용하는 것보다 좋은 코드를 작성할 수 있습니다.

요약

• 동시성을 처리하기 위해서는 함수를 coroutineScope로 래핑한 다음, 스코프 내에서 빌더를 사용해야 합니다.
• 모든 것은 스코프 내에서 빌더를 호출함으로써 시작되어야 합니다.
• 대부분의 프로젝트에서 스코프는 한 번 정의되면 다시 선언할 필요가 없으며, 다른 컨텍스트를 사용하거나 예외처리에 익숙해지는 방법도 학습이 필요합니다 !

https://m.yes24.com/Goods/Detail/123034354

코틀린 코루틴 - 예스24