[Coroutine] Kotlin Coroutine 필요성

💡 다양한 비동기 처리 방법에 대하여 알아보고, 예제를 통해서 학습하였습니다.

코투린이 없다면?

일반적인 비동기 로직

• 일반적인 프론트엔드(안드로이드) 단에서 애플리케이션 로직을 구현하는 방법은 아래와 같습니다.
  • 다양한 소스로부터 데이터를 받음
    • API, 뷰 구성요소, 데이터베이스, 다른 앱
  • 데이터 처리
  • 가공된 데이터로 작업
    • 뷰 동기화
    • 데이터베이스 저장
    • API로 전송
• 일반적인 비동기 연산 라이브러리는 아래와 같이 사용됩니다.

fun onCreate() {
    val news = getNewsFromApi()
    val sortedNews = news
        .sortedByDescending { it.publishedAt }
    view.showNews { sortedNews }
}

• 안드로이드에서는 하나의 앱에서 뷰를 다루는 스레드가 단 하나만 존재하므로, 위 코드는 가장 중요한 스레드를 블로킹하게 됩니다.
• 이러한 방식으로는 구현한다면 앱 크래시(비정상 종료)가 발생할 것입니다.

스레드로 전환

• 스레드를 활용한다면 위 문제를 가장 직관적으로 해결할 수 있습니다.
• 블로킹이 가능한 스레드를 먼저 활용하고, 이후에 메인 스레드로 전환합니다.

fun onCreate() {
    val news = getNewsFromApi()
    val sortedNews = news
        .sortedByDescending { it.publishedAt }
    runOnUiThread {
        view.showNews { sortedNews }
    }
}

• 이러한 방식 역시 아래와 같은 문제를 가지고 있습니다.
  • 스레드가 실행되었을 때 멈출 수 있는 방법이 없어 메모리 누수로 이어질 수 있음
  • 스레드에 대한 비용과, 복잡도가 증가함
  • 코드가 길어지고, 이해하기 어려움
• 생성 된 스레드를 제거하지 않으면, 스레드는 주어진 작업을 계속 수행한 후 더 이상 존재하지 않는 뷰를 수정하려고 시도합니다.
• 백그라운드 예외를 유발하거나 예상하기 어려운 결과가 발생할 수 있습니다.

콜백 함수 활용

• callback은 함수를 논블로킹(non-blocking)으로 만들고, 함수의 작업이 끝났을 때 호출된 콜백 함수를 넘겨주는 방식입니다.

fun onCreate() {
    getNewsFromApi { news ->
        val sortedNews = news
            .sortedByDescending { it.publishedAt }
        view.showNews(sortedNews)
    }
}

• 위와 같이 콜백을 통해 구현한다면, 중간에 작업을 취소할 수 없습니다.
• 취소할 수 있는 콜백도 가능하지만 이는 상당히 어려우며, 각 함수에 대한 취소 구현을 해야하며 모든 객체를 분리해서 모아야 한다는 단점이 있습니다.

fun showNews() {
    getConfigFromApi { config ->
        getNewsFromApi(config) { news ->
            getUserFromApi { user ->
                view.showNews(user, news)
            }
        }
    }
}

• 위 코드에서는 병렬 처리를 기대하지만, 현재 두 작업을 동시에 처리하기는 어렵습니다.
• 콜백을 활용할수록 들여쓰기가 상당히 많아지며, 가독성이 떨어지는 상황이 발생하는데 이를 콜백 지옥(callback hell)이라 부릅니다.

RxJava와 Reactor는 어때?

• 안드로이드와 백엔드에서 자주 활용되는 자바 언어에서는 RxJava와 Reactor와 같은 리액티브 스트림을 활용할 수 있습니다.
• 이 방법을 사용하면 데이터 스트림 내에서 일어나는 모든 연산을 시작, 처리, 관찰할 수 있습니다.
• 리택티브 스트림은 스레드 전환과 동시성 처리를 지원하며, 병렬 처리가 가능합니다.

RxJava 활용

fun onCreate() {
    disposable += getNesFromApi()
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .map { news ->
            news.sortedByDescending { it.publishedAt }
        }
        .subscribe { sortedNews ->
            view.showNews(sortedNews)
        }
}

• 위 예제에서 disposables 를 활용하여 사용자가 스크린을 빠져나간 경우 스트림을 취소할 수 있습니다.
• callback과 비교
  • 메모리 누수가 없고, 취소가 가능합니다.
  • 스레드를 적절하게 사용할 수 있습니다.
  • 동시성 처리를 보장할 수 있습니다.
• 하지만 RxJava는 구현하기 매우 복잡하다는 단점이 있습니다.

fun onCreate() {
    val news = getNewsFromApi()
    val sortedNews = news
        .sortedByDescending { it.publishedAt }
    view.showNews { sortedNews }
}

• 위 코드는 비정상 종료를 발생시키지만, 가장 이상적인 코드입니다.
• 위 코드와 비교했을 때, RxJava는 매우 복잡하다는 것을 알 수 있습니다.
• subscribeOn, observeOn, subscribe… 등 RxJava를 활용하기 위해서 다양한 함수를 배워야 합니다.
• 또한 취소하는 작업 또한 명시적으로 표시해야하며, 객체를 반환하는 함수들은 Observable이나 Single 클래스로 반드시 래핑(wrapping)해야 한다는 단점이 있습니다.
• 이는 RxJava를 도입하기 위해서 많은 코드를 수정해야 한다는 뜻합니다.

Kotlin Coroutines

• 코틀린 코루틴이 도입해야 하는 이유는 위 단점들을 해결할 수 있기 때문입니다.
• 코루틴의 가장 핵심 기능은 특정 지점에서 멈추고 이후에 재개할 수 있다는 것입니다..!
• 이는 메인 스레드에서 실행하고, API에서 데이터를 얻어올 때 잠시 중단이 가능하다는 의미입니다.
• 코루틴을 중단시켰을 때 스레드는 블로킹되지 않으며, 뷰를 바꾸거나 다른 코루틴을 실행하는 등의 또 다른 작업이 가능합니다.
  • 데이터가 준비되면 코루틴은 메인 스레드에서 대기하고 있다가 메인 스레드가 준비되면 멈춘 지점에서 다시 작업을 수행합니다.
  • 이는 극히 드문 상황이며, 스레드를 기다리고 있는 코루틴이 쌓여있는 경우를 나타냅니다.

val scope = CoroutineScope(Dispatchers.Main)

fun onCreate() {
    scope.launch { updateNews() }
    scope.launch { updateProfile() }
}

suspend fun updateNews()
suspend fun updateProfile()

• 위 동작은 아래와 같은 순서로 실행됩니다.
  1. updateNews() 함수가 실행 됩니다.
  2. updateNews() 함수가 네트워크 응답을 기다리는 동안 메인 스레드는 updateProfile() 함수가 사용합니다.
  3. updateProfile() 호출이 중단되지 않는다고 가정한다면, 메인 스레드 내에서 멈추지 않고 실행됩니다.
  4. updateProfile() 동작이 완료되면, 메인 스레드는 updateNews()를 처리하는 코루틴에 의해 updateNews()의 작업을 완료합니다.
• 이제 코틀린 코루틴을 활용해 아래와 같은 이상적인 동작을 수행할 수 있습니다.

fun onCreate() {
    viewModelScope.launch {
        val news = getNewsFromApi()
        val sortedNews = news
            .sortedByDescending { it.publishedAt }
        view.showNews { sortedNews }
    }
}

여러 개의 엔드포인트를 호출하는 경우

• 스레드를 블로킹하는 문제를 해결했으므로, 이제 다음과 같은 문제에 접근해야 합니다.
• 만약 3개의 엔드포인트를 호출해야 하는 상황이 발생했다고 가정해봅니다.

fun showNews() {
    viewModelScope.launch {
        val config = getConfigFromApi()
        val news = getNewsFromApi(config)
        val user = getUserFromApi()
        view.showNews(user, news)
    }
}

• 위 코드는 작동하는 방식이 효율적이지 않다는 단점이 있습니다.
• 호출은 순차적으로 일어나기 때문에, 한 작업에 1초씩 걸린다면 API 호출에 3초를 기다려야 합니다.
• 이런 경우 async 와 같은 코틀린이 제공하는 코루틴 라이브러리를 활용할 수 있습니다.
  • async() : 요청을 처리하기 위해 만들어진 코루틴을 즉시 시작하는 함수
  • await() : 호출 후 결과를 기다리는 함수

fun showNews() {
    viewModelScope.launch {
        val config = async { getConfigFromApi() }
        val news = async { getNewsFromApi(config) }
        val user = async { getUserFromApi() }
        view.showNews(user.await(), news.await())
    }
}

• 위 경우를 활용하면 병렬 호출이 가능하며, 2초만에 작업을 끝낼 수 있습니다.

for 문을 활용하는 경우

• 코투린을 활용하면 for, 컬렉션을 처리하는 함수를 블로킹 없이 구현이 가능합니다.

fun showAllNews() {
    viewModelScope.launch {
        val allNews = (0 until getNumberOfPages())
            .map { page -> async { getNewsFromApi(page) } }
            .flatMap { it.await() }
        view.showAllNews(allNews)
    }
}

• 위처럼 모든 뉴스를 병렬처리를 통해서 받아오는 로직을 구현할 수 있습니다.

정리

• 코틀린 코루틴을 사용하는 가장 중요한 이유는 스레드를 사용하는 비용이 크게 감소한다는 것입니다.
• 스레드는 명시적으로 생성되고 유지되며 메모리를 할당합니다.

fun main() {
    // Thread 활용
    repeat(100) {
        thread {
            Thread.sleep(1000)
            print(".")
        }
    }

    // Coroutine 활용
    repeat(100) {
        launch {
            delay(1000)
            print(".")
        }
    }
}

• 위 코드의 Thread를 활용한 부분을 살펴보면, 많은 수의 스레드를 활용해서 스레드당 1초씩 잠들게 만듭니다.
  • 여기서 잠드는 동작은 데이터베이스 또는 다른 서비스로부터 응답을 기다리는 상황을 나타냅니다.
• 이 프로그램을 각자의 컴퓨터에서 실행한다면, 모든 점을 찍는 데 상당한 시간이 걸릴 것입니다.
• 반면에 Coroutine을 활용한 부분에서는 스레드를 재우는 대신 코루틴을 중단시킵니다.
• 프로그램을 실행하면 1초 뒤에 모든 점을 출력하게 됩니다.
• 이를 통해 저렴하고 안전한 방식의 동작을 기대할 수 있습니다.

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

코틀린 코루틴 - 예스24