Kotlin Coroutine의 개념과 동작원리

들어가며

안녕하세요. 원더월 모바일팀에서 앱개발을 맡고 있는 최대순입니다.

현재 많은 프로그램들이 비동기 형태로 짜여지거나 비동기 형태를 지향하는 형태 ( Asynchronous or non-blocking programming ) 로 구성되고 있습니다. 따라서 이미 많은 언어 또는 라이브러리들이 비동기 형태의 프로그래밍을 쉽게 할 수 있도록 지원을 하고 있는데요. 코틀린 또한 비동기 프로그래밍을 지원하기 위한 방법들 중 하나로서 coroutine 을 제공하고 있습니다.

이번 포스트에서는 코틀린에서 지원하고 있는 coroutine 이 어떻게 동작하는지에 대해서 다루어보고자 합니다. 먼저 coroutine 의 개념을 살펴보도록 하겠습니다.

Coroutine 이란?

coroutine은 일종의 프로그래밍 개념이라고 볼 수 있습니다. 위키피디아에서는 coroutine 을 아래와 같이 정의 하고 있습니다.

Coroutines are computer program components that generalize subroutines for non-preemptive multitasking, by allowing execution to be suspended and resumed

위 정의를 풀어보면 coroutine은 suspend 와 resume 을 통해 subroutine들 간의 비선점형 멀티테스킹을 할수 있도록 하는 프로그램 구성요소라는 의미인데요. 단순히 사전적 정의만으로는 coroutine이 어떤 역할을 하는지 이해하기 쉽지 않습니다. 해당 의미에 대해서 좀 더 상세히 알아보도록 하겠습니다.

일반적인 프로그램들은 메인 루틴과 서브 루틴으로 이루어져 있습니다. 보통 프로그램을 시작하는 곳이 메인 루틴이 되고 메인 루틴은 다양한 서브 루틴으로 이루어져 있습니다. 많이 알려진 버스 티켓팅 예제를 통해서 해당 내용을 설명하겠습니다.

fun main() {
    linedUp()
    ticketing()
    takeTheBus()
}

fun linedUp() {
    println("lined up")
    Thread.sleep(2000)
}

fun ticketing() {
    println("ticketing")
}

fun takeTheBus() {
    println("waiting the bus")
    Thread.sleep(2000)
    println("take the bus")
}

위 코드에서 프로그램의 시작점인 main() 은 메인 루틴이 되고 그 안에 호출되는 각각의 함수는 서브 루틴이라고 볼 수 있습니다. 서브루틴은 진입점과 종료시점을 갖게 되는데 일반적으로 사용하는 함수의 호출 시점과 return 시점이 진입과 종료 시점이 됩니다. 서브루틴은 진입점 부터 종료시점까지 중단없이 실행이 되기 때문에 각각의 서브루틴들 사이의 관계는 계층적, 직렬적 관계가 됩니다.

이제 위 예제에서 비동기 처리를 적용해보겠습니다. 줄을 서 있는 동안, 그리고 버스를 기다리는 동안 음악을 듣는다고 가정 하겠습니다.

fun main() {
    asyncLinedUp() {
        stopMusic()
        ticketing()
        asyncTakeTheBus {
            stopMusic()
        }
        asyncPlayMusic()
    }
    
    asyncPlayMusic()

}

fun asyncLinedUp(myTurn: () -> Unit) {
    Thread {
        println("lined up")
        Thread.sleep(2000)
        myTurn.invoke()
    }.start()
}

fun asyncTakeTheBus(onTime: () -> Unit) {
    Thread {
        println("waiting the bus")
        Thread.sleep(2000)
        onTime.invoke()
        println("take the bus")
    }.start()
}

var playingMusic = false

fun asyncPlayMusic() {
    Thread {
            println("play music")
            playingMusic = true
            while(playingMusic) {
                println("listening..")
                Thread.sleep(500)
            }
    }.start()
}

fun stopMusic() {
    playingMusic = false
    println("stop music")
}

프로그램은 다음과 같은 순서로 동작하게 됩니다.

( 티켓팅을 기다린다. -> 기다리면서 음악을 듣는다. -> 내 차례가 되면 음악을 멈추고 티켓팅을 한다. -> 버스를 기다린다 -> 버스가 도착한다. -> 음악을 멈추고 버스를 탄다. )

비동기 처리를 해주면서 코드가 조금 더 복잡해졌습니다. 이런 단순히 thread 와 callback 을 이용한 비동기처리는 몇가지 문제점을 가지고 있습니다.

첫번짼는 코드의 복잡성입니다. 각각의 루틴들은 독립적인 thread 안에서 동작을 합니다. 따라서 각 루틴들이 서로에게 영향을 주기 위해서는 thread 사이에 통신이 필요하게 됩니다. 이는 코드를 복잡하게 하고 관리하기 힘들게 합니다. 또한 thread/callback 구조는 코드 상으로 흐름을 파악하기가 쉽지 않습니다. ( 위 코드에서도 쉽게 프로그램이 어떤 순서로 동작되는지 파악하기가 쉽지 않습니다. )

두번째는 비용입니다. 기본적으로 thread 는 OS 에서 할당하고 관리를 하게 됩니다. OS 에서 thread 들의 작업을 적절하게 분배하기 위해 코어에 각각의 태스크들을 적절하게 할당, 회수 작업을 하게 됩니다. 이처럼 OS 에 의해서 작업이 할당되는 것을 preemptive multitasking 이라고 합니다. OS 가 각 thread 의 작업을 스케줄링 할 때 context switching 이 필요하게 됩니다. 이때 switching 비용이 발생하게 됩니다. 무분별한 thread 생성이 결국 많은 리소스를 소비하게 하여 전체적은 프로그램의 성능을 저하시킬 수 있습니다.

이런 thread/callback 을 이용하여 비동기 프로그래밍을 하는 과정에서는 코드의 복잡도와 비용의 증가로 많은 문제를 야기 할 수 있습니다. 그래서 이런 점들을 해결하기 위한 다양한 방법들이 나오기 시작합니다. 언어 자체에서 이런 문제들을 해결하기 위한 다양한 방법들이 등장하기도 하며 다양한 비동기 프로그래밍을 위한 라이브러리들도 등장하였습니다. 이런 언어적 지원과 라이브러리 지원들은 자체적으로 thread 를 관리해주고 callback 지옥에 빠지지 않고 단순하고 파악하기 쉬운 비동기 프로그래밍을 하도록 지원을 해줍니다.

coroutine 또한 이런 단점들을 해결해주는 언어적 기능 중 하나입니다. 위에서 본 coroutine 의 정의에서 non-preemptive multitasking 라는 것을 확인 할 수 있는데요, coroutine 는 thread 와 callback 을 통한 비동기 프로그래밍에서의 단점들을 non-preemptive multitasking 방식으로 해결하고 있습니다.

non-preemptive multitasking 란 무엇일까요? coroutine 은 os 가 thread 들의 작업을 스케줄링 하도록 하지 않고 subroutine 간의 상호작용을 통해서 언어적으로 또는 코드 작성자가 직접 작업을 스케줄링 할 수 있도록 합니다. ticketing 예제를 coroutine 으로 구현하면서 좀 더 자세히 알아보겠습니다.

fun main() {
    runBlocking {
        val lineUp = launch {
            coroutineLinedUp()
        }
            
        val playMusicWithLinedUp = launch {
            coroutinePlayMusic()
        }
            
        lineUp.join()
        playMusicWithLinedUp.cancel()
        coroutineTicketing()
            
        val waitingBus = launch {
            coroutineWaitingTheBus()
         }
            
        val playMusicWithWaitingBus = launch {
            coroutinePlayMusic()
        }
        
        waitingBus.join()
        playMusicWithWaitingBus.cancel()
        coroutineTakeTheBus()
    }
}

suspend fun coroutineLinedUp() {
    println("lined up")
    delay(2000)
}

fun coroutineTicketing() {
    println("ticketing")
}

suspend fun coroutineWaitingTheBus() {
    println("waiting the bus")
    delay(2000)
}

fun coroutineTakeTheBus() {
    println("take the bus")
}

suspend fun coroutinePlayMusic() {
    println("play music")
    while(true) {
        println("listening..")
        delay(500)
    }
}

kotlin 에서 제공하는 coroutine 을 통해 위 예제를 변경해보았습니다. 이 포스트에서는 coroutine 에 대한 개념만 설명하기 위해 kotlin coroutine 에 대한 자세한 설명은 생략하고 코드를 이해하는데 무리가 없도록 runBlocking 과 launch 함수에 대해서만 간단히 설명하겠습니다.

runBlocking 은 현재 thread 를 block 하는 coroutine 을 생성하는 함수 입니다. 즉 runBlocking 이 호출된 thread 는 runBlocking 내의 작업이 완료되기 전까지 다른 작업을 하지 못합니다. 이 함수는 프로그램의 main 함수 등 특수한 경우에 사용되도록 설계가 되었는데요, 자세한 설명은 일단 생략하겠습니다.

launch 함수는 현재 thread 에 대한 blocking 없이 실행되는 coroutine 을 생성합니다. 즉 현재 thread 에 다른 작업을 할당 할 수 있습니다.

위 코드에서는 크게 runBlocking, lineUp, playMusic 3개의 coroutine 이 상호작용을 하고 있습니다. runBlocking 은 main thread 를 잡고 있으며 작업이 완료 될 때까지 프로그램이 종료 되지 않도록 합니다. 즉 main routine 이 됩니다.

main routine 은 lineUp 과 playMusic 이라는 2개의 coroutine 을 생성하고 실행합니다. lineUp 과 playMusic 은 동시성을 보장하면서 각각의 routine 을 수행합니다. 그 후 main routine 에서 lineUp.join() 이라는 함수를 호출합니다. 이는 lineUp coroutine 이 완료 될때까지 현재 routine 을 일시정지 시키고 lineUp coroutine 이 완료가 되면 그 때 routine 을 다시 재개 하겠다라는 의미입니다. lineUp coroutine 이 완료가 되면 playMusic coroutine 을 cancel 시키고 ticketing 과 takeTheBus 를 호출하는 구조 입니다. 이를 도식화 해보면 아래 그리과 같습니다.

위 그림처럼 coroutine 을 이용하여 routine 과 routine 간의 관계 정의만을 통해서 동시성이 보장되는 비동기 프로그래밍을 하였습니다. 일반적인 subroutine 과는 다르게 coroutine 에서는 비동기적으로 routine 을 실행 할 수 있었으며 각 루틴에서 실행되는 작업들을 중간에 일시정지( lineUp.join() ) 하고 임의의 시점에 재개 할 수 있습니다. 이를 통해 코드는 더 읽기 쉬워졌으며 개발자가 정의한 모든 subroutine 을 같은 context 에서 (해당 프로그램에서는 main thread) 쉽게 실행 할 수 있게 합니다. ( 위 이미지는 개발자가 정의한 코드 영역에서의 관계를 도식화 한 것으로 실제로는 위 프로그램이 한개의 thread 에서 동작하는 것은 아닙니다. 언어적으로 각 루틴들의 스케줄링을 위한 thread 를 할당 하여 사용하고 있을 수 있습니다. ) 이처럼 coroutine 은 routine 과 routine 간의 관계를 정의하고 정의된 관계에 따라 스케줄링을 언어레벨에서 해줌으로서 코드를 좀 더 명확하게 하고 context switching 비용을 줄일 수 있게 합니다.

JVM 상에서의 Kotlin Coroutine 동작구조

kotlin의 장점 중 하나는 JVM기반 언어로 JVM 바이트코드로 변환이 가능하다는 점입니다. 그럼 kotlin coroutine 은 어떻게 위와 같은 비동기 프로그래밍이 가능하게 하는 것일까요? kotlin coroutine 은 기본적으로 CPS 와 state machine 을 이용하여 이와 같은 비동기 프로그래밍이 가능하게 합니다.

일반적인 함수 ( subroutine ) 은 return 이 되면 최초 호출 부인 caller 로 돌아오게 됩니다. 그러나 kotlin coroutine 에서는 caller 로 리턴하지 않고 각 subroutine 의 상태를 컨트롤 하기 위해서 따로 전달 받은 callback 함수를 호출하게 됩니다. return 대신에 지속적으로 이어나갈 새로운 context 를 continuation 이라고 부릅니다. CPS 란 continuation passing style 의 약자로 subroutine 에서 caller 로 return 하는 것이 아닌 continuation 을 받아서 subroutine 의 작업값을 continuation 으로 passing 하는 프로그래밍 방법을 의미합니다.

kotlin coroutine 에서는 이런 CPS 로 각 subroutine 들을 제어 합니다. subroutine 은 caller 의 context 로 돌아가는 대신 정의된 continuation 에 의해 제어되게 됩니다.

kotlin coroutine 에서 각 subroutine 들은 continuation 에 의해서 제어된다고 했는데 어떤 방법으로 제어가 되는 것일까요? kotlin coroutine 은 state machine 을 통해서 subroutine 의 동작을 제어하게 됩니다. 다음은 KotlinConf 2017 — Deep Dive into Coroutines on JVM 에 소개된 예제입니다.

suspend fun postItem(item: Item) {
    val token = requestToken()
    val post = createPost(token, tiem)
    processPost(post)
}

위 예제에서 각각의 routine 들은 coroutine 으로서 동작을 합니다. postItem 은 실제로는 다음과 같은 형태로 동작을 하게 됩니다.

fun postItem(item: Item, cont: Continuation) {
    val sm = object : ContinuationImpl { 
        fun resume() {
            postItem(null,this)
        }
    }
    switch(sm.label) {
        case 0:
          sm.item = item
          sm.label = 1
          val token = requestToken(sm)
        case 1:
          val item = sm.item
          val token = sm.result
          val post = createPost(token, item, sm)
}
fun requestToken(cont: Continuation) {
  //...
}
fun createPost(token: Token, item: Item, cont: Continuation) {
  //...
}

실제 kotlin coroutine 코드를 decompile 해보면 위와 같은 형태로 되어 있는 것을 알수 있습니다. (물론 위의 예제는 매우 단순화 시킨 것입니다. ) 앞서 말한 봐와 같이 coroutine 은 CPS 형태로 동작함으로 continuation 을 파라미터로 받고 있습니다. postItem 함수에서는 reqeustToken() 과 createPost() 루틴간의 관계 정의를 위해서 state machine 인 continuation 을 만들게 됩니다. 이제 reqeustToken() 과 createPost() 루틴은 postItem 에서 정의된 state machine 에 의해서 동작이 결정되게 됩니다. 초기 label 이 0 임으로 최초에는 switch 문의 reqeustToken() 이 수행됩니다. 이때 이 후의 context 를 결정하기 위해 continuation 으로 state machine 를 넘겨줍니다. 그리고 이 state machine 에는 현재의 상태값들을 저장합니다. ( label 을 변경하고 파라미터로 들어온 item 을 저장 ). requestToken() 내부에서는 다시 continuation 으로 넘겨받은 state machine 에 return 값을 저장해주게 됩니다. 그리고 resume 을 통해서 복귀 해야할 할 context 를 실행합니다. 이때도 역시 continuation 을 넘겨 주면서 변경된 상태에 대한 값들이 저장된 상태로 실행 될 수 있게 합니다. 이를 통해서 루틴들 사이에 suspend, resume 등이 가능하게 합니다.

마치며

이번 포스트에서는 coroutine에 대한 개념과 JVM 상에서의 동작원리를 간단하게 정리해 보았습니다.

단순히 사용법 대해서만 알고 코드를 구성하기보다 내부적인 동작구조와 원리를 파악한 후 작성하는 코드는 개발함에 있어서 더 깊은 고민을 할 수 있게하고 이런 고민을 통해 보다 나은 소프트웨어를 개발 할 수 있다고 생각합니다.

이번 포스트가 coroutine을 사용할 때 보다 깊은 고민을 할 수 있는데 도움이 되었으면 합니다.