[Kotlin] 코루틴 공식 가이드 뽀개기 Part 1

Delight Yoon·2022년 11월 12일

Kotlin

목록 보기

6/6

Coroutines basics

먼저, 코루틴을 실습하기 전에, 다음과 같은 dependency를 추가하여 라이브러리를 다운로드 하자.

implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.1")

그리고 Sync Now를 해주자. InteliJ 를 사용하는 경우, build.gradle에 추가하였을 때, 코끼리와 리프레시 버튼같이 생길 것이다. 그것을 눌러주어 다운로드 해주자.

예제 가장위에 import 구문을 다음과 같이 추가해주자.

import kotlinx.coroutines.*

Your first coroutine

import kotlinx.coroutines.*

fun main() = runBlocking { 
    launch { 
        delay(1000L) 
        println("World!") 
    }
    println("Hello") 
}

코루틴은 일시중단이 가능하다는 것을 보여주는 예제이다.

코드를 살펴보자. 설명 내용이 길더라도 앞으로 코루틴 예제들을 살펴보면서 알아야 할 지식들이니 읽어주기를 바란다.

delay는 말 그대로 ms 단위의 시간을 지연시키는 함수이다.

다만, delay 는 suspend 함수이므로, 현재 launch가 실행되고 있는 main 스레드를 일정 시간동안 일시 중단시킨다. (일시 중단된 메인 스레드의 제어권한은 다른 코루틴이 넘겨받을 수 있다.)

뒤에서 배우겠지만, launch에 CoroutineContext 파라미터를 생략하면, 상위 context를 물려받고 그 위에서 코루틴이 실행된다. (따라서 이 곳에서 launch는 main 스레드에서 실행되는 것이다.)

여기서 중요한 점은일시중단이 가능한 함수 suspend fun는 Coroutine 내부, 또는 Coroutine Scope 안에서만 호출할 수 있다는 성질이다.

우선 runBlocking 은 코루틴 빌더 중 하나로써, 안에 있는 모든 연산이 끝나기 전까지, runBlocking이 현재 실행되고 있는 main 스레드를 블럭한다.

예제의 실행을 위해서 main 스레드가 종료되는 것을 막기 위함이라고 생각하자.

실제, 안드로이드 프로젝트에서 UI 상호작용을 하는 UI 스레드라고도 불리는 Main 스레드에서는 절대 runBlocking을 사용해서는 안된다. 일반적으로, 5초 이상, UI 스레드가 블럭이 되면, ANR이 발생하여, 앱이 종료되기 때문이다.

실행결과는 다음과 같다.

Hello
World!

서론이 길었다. 코루틴을 처음 접하는 사람을 위해서 설명을 하기 위함이었다.
따라서, delay 함수에 의해서 1000ms 동안, 일시중단 되어 Hello가 먼저 출력되고, World!가 나중에 출력되는 모습이다.

이해가 안된다면, launch는 코루틴 빌더로써, launch 내부의 코루틴과 main 스레드의 Hello를 출력되는 부분은 동시에 실행되는 루틴으로 볼 수 있다.

그리고 여기서 delay가 없더라도, launch는 코루틴을 스케줄링하는 과정을 거친 후, 실행하는 성질이 있기 때문에, 위 실행결과와 같이 Hello가 먼저 출력되고, World! 가 스케줄링 되고 실행되기 때문에 늦게 출력된다.

자 이제 두 번째 예제를 살펴보자....

코루틴 공식 가이드의 첫 번째 예제인데, 설명이 너무 길었다.
다들 도망가지 않기를 바란다..

Extract Function Refactoring

import kotlinx.coroutines.*

fun main() = runBlocking {

    launch {
        /*
        delay(1000L)        // coroutine 안에서 호출이 가능하다.
        println("World!")

        launch 내에 구현부를 메서드로 만들어 호출만하여 구현해보자.
         */
        myWorld()
    }

    println("Hello")
}

suspend fun myWorld() {
    delay( 1000L )  // delay() 는 suspend fun 이므로, myWolrd() 또한 suspend fun 이 되어야 호출할 수 있다.
    println("World!")
}

위 첫 번째 예제와 같은 코드이다. 하지만 launch 내부의 코드를 Extract 하여 function을 만들며 리팩토링 하자는 예제이다.

launch 내부에 구현부는 위에서 설명한 바와 마찬가지로 delay 함수를 사용하는 구문이 있기 때문에, Coroutine 이 실행되는 내부 또는 suspend fun 안에서 실행되어야 한다.

그래서 함수 myWorld() 는 suspend fun이 되어야 한다.

Scope builder

import kotlinx.coroutines.*

fun main() = runBlocking {
    doWorld()
}

suspend fun doWorld() = coroutineScope {
    launch {
        delay(1000L)
        println("World!")
    }
    println("Hello")
}

우리는 앞으로 코루틴을 사용하게 될 때, 코루틴이 실행되는 범위인 CoroutineScope를 정의하여 사용하게 된다.

CoroutineScope 를 만드는 대표적인 builder로는 CoroutineScope를 상속하는 CoroutineScope , GlobalScope , runBlocking , withContext , ... 여러가지가 있는데, 우리는 먼저 사용자 지정 CoroutineScope를 만드는 coroutineScope와 runBlocking에 대해서 살펴보겠다.

먼저 runBlocking은 첫 번째 예제와 같이, 자신의 내부의 코루틴의 실행을 마치기 전까지 현재의 스레드를 블럭 한다는 성질이 있다.

마찬가지로, 예제의 실행을 마치기 위해 메인 스레드가 종료되지 않게끔 블럭한다고 생각하면 된다.

public suspend fun <R> coroutineScope(block: suspend kotlinx.coroutines.CoroutineScope.() -> R): R { /* compiled code */ }

사용자 지정 CoroutineScope는 coroutineScope{ }를 사용하여 만들 수 있으며, 이 사용자 지정 CoroutineScope 또한 자식들의 실행을 기다리긴 한다. 하지만, 기다리는 과정에서 스레드를 블럭하지 않고, 일시중단 후, 재개 한다는 성질이 있다.

그러므로 doWorld()함수는 coroutineScope{}로 생성되었으며, suspend fun을 인자로 받아 실행시킨다는 성질이 있으므로 suspend fun이 되어야 한다.

참고

스레드를 블럭 하게되면, 그 스레드는 아무 작업도 하지 못하고, 작업을 기다려야 하는 성질이 있다. 그리고, 스레드를 전환하는 과정을 Context-Switching이라고도 하는데, 이 과정에서 많은 오버헤드가 발생하고 성능을 저하시키며, 안드로이드에서는 메인 스레드를 블럭하게 되면, ANR이 발생하여 앱이 강제종료된다.

하지만 사용자가 지정한 범위 만큼의 코루틴을 실행하는 사용자 지정 CoroutineScope를 정의하는 것은, 현재 스레드를 일시중단하고, 중단점으로부터 다시 재개되며, 일시중단되었을 때는, 현재 스레드 내부의 다른 코루틴에게 제어권한을 전달할 수 있다.
( 코루틴의 특징 - 경량 스레드, 비동기 프로그래밍 지원, 일시중단 가능한 등 )

Global Scope

다음 예제를 살펴보기 전에, GlobalScope와 Structured Concurrency에 대해서 살펴보고자 한다.

먼저 GlobalScope부터 살펴보자.

import kotlinx.coroutines.*

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

GlobalScope는 프로그램(앱)의 전체 생명주기를 아우르는 범위에서 코루틴을 실행하는 Scope builder이다.

이것은 무조건 좋은 것이 아니냐? 라고 생각할 수도 있는데, 쓸데없이 전체 생명주기에서 코루틴을 실행할 필요가 없다. 실행할 필요가 있다면 사용해주어도 된다.

하지만, 그렇다고 무조건 좋은 것은 아니다. 실행할 필요가 있다면, 그 실행을 마치기 전까지 기다려야 한다.

Why ? -> GlobalScope is Daemon Thread ( GlobalScope은 데몬 스레드와 유사하다.)

데몬 스레드 - 우선순위가 가장 낮은 스레드. 프로그램이 종료될 때, 실행 여부를 따지지도 않고, 만약 실행 중이라면, kill 하고, 종료시켜버린다.

그래서 위 예제에서도 Hello를 출력하고 무려 2000ms 동안 main스레드가 기다려준다.

같은 스레드에서 동작하는 것이 아니냐? 라고 생각할 수 있는데 GlobalScope.launch{} 와, main 스레드의 실행구문, 심지어 그냥 launch를 실행하는 것은 서로 다른 스레드에서 동작한다.

import kotlinx.coroutines.*

fun main() = runBlocking {

    GlobalScope.launch {    // GlobalScope - 코루틴의 생명주기가 전체 애플리케이션 생명주기와 같음.
        delay(1000L)
        println("World!")
    }

    println("Hello")
    delay(500L)
    // 이러한 부분에서 GlobalScope 가 DaemonThread 와 유사하다.

}

실행결과

Hello

Process finished with exit code 0

이 코드에서는 World!가 출력되지 않고, 종료된다. GlobalScope에서의 코루틴은 kill되고, main스레드가 종료됨에 따라 프로그램이 종료되기 때문이다.

Structured Concurrency

다음은 Structured Concurrency원칙이다. 직역하면 구조적 동시성 원칙인데, 코루틴은 이러한 원칙을 지키며 실행된다.

그래서 Structured Concurrency, 구조적 동시성 원칙은 무엇이냐 ? 특정 범위에서 코루틴이 실행되고 있을 때, 하위 코루틴들의 실행이 마치기까지를 기다려야 한다는 것이다.

모든 하위 코루틴의 실행이 완료되기 전까지 범위를 완료할 수 없다.

runBlocking이나 coroutineScope를 사용하면, 현재 스레드를 블럭 또는 일시중단 함으로써 이러한 구조적 동시성 원칙을 지킬 수 있고,

import kotlinx.coroutines.*

fun main() = runBlocking {
    /*
    val job = GlobalScope.launch {
        delay(3000L)
        println("World!")
    }

    println("Hello")
    job.join()
     */

    // Structured Concurrency 란 ? 구조적 동시성 원칙.
    // => 위와 같이 job은 Global Scope에서 실행되는 작업이기 때문에, 데몬 스레드로 취급을 하므로,
    // join()을 하지 않으면 "World!" 를 출력하지 못 하고 종료된다.

    launch {
        delay(3000L)
        println("World!")
    }
    // 이와 같이 runBlocking{}의 자식 코루틴으로 실행하였을 때는, runBlocking은 자식 코루틴이 종료하기까지
    // 기다리게 된다. 이러한 구조적 동시성 원칙을 사용하면 join()을 사용하지 않아도 된다.

    println("Hello")
}

밑에서 배우겠지만, 다음과 같은 GlobalScope의 launch 의 job 객체를 join() 하여 메인 스레드를 일시중단 시킴으로써, 구조적 동시성 원칙을 실천할 수 있다.

Scope builder and concurrency

import kotlinx.coroutines.*

fun main() = runBlocking {
    doWorld()
    println("Done")
}

suspend fun doWorld() = coroutineScope { 
    launch {
        delay(2000L)
        println("World 2")
    }
    launch {
        delay(1000L)
        println("World 1")
    }
    println("Hello")
}

다음 예제코드를 살펴보면 doWorld() 함수를 coroutineScope{}로 정의함으로써, 하위 코루틴 launch들이 완료되기 전까지 기다리며 구조적 동시성 원칙을 지키는 것을 확인할 수 있다.

실행결과는 다음과 같다.

Hello
World 1
World 2
Done

하위 launch 들의 delay 값이 다르므로, 다음과 같은 실행결과를 확인할 수 있다.

An explicit job

import kotlinx.coroutines.*

val job = launch { // launch a new coroutine and keep a reference to its Job
    delay(1000L)
    println("World!")
}
println("Hello")
job.join() 
println("Done")

명시적인 Job 이라는 뜻의 예제이다.
우리는 위에서 launch를 사용하여 코루틴을 실행할 수 있는 방법에 대해서 배웠다.
launch는 Job 객체를 반환하고, Job객체를 참조하여 코루틴 작업을 시작하거나 취소할 수 있고, 그 작업이 끝나기 전까지 기다리게끔, 일시중단을 걸 수 있다.

위 예제는 job이라는 변수로 launch의 Job객체를 명시적으로 참조할 수 있다는 것을 전달하는 예제이다.

job.join()을 사용하여, "Hello"를 출력한 후, 메인 스레드를 일시 중단시킨다. 그리고 job이 실행되며, "World!"를 출력 후, "Done"을 출력하게 되는 것이다.

실행결과

Hello
World!
Done

Coroutines are light-weight

import kotlinx.coroutines.*

fun main() = runBlocking {
    repeat(100_000) { // launch a lot of coroutines
        launch {
            delay(5000L)
            print(".")
        }
    }
}