Kotlin in Action - 14장 코루틴

📖 14.1 동시성과 병렬성

동시성
- 여러 작업을 동시에 실행하는 것
- CPU 코어 하나에서 동시성 사용 가능
병렬성
- 코드를 여러 부분으로 나눠서 동시에 수행할 수 있는 능력
- 여러 CPU 코어에서 물리적으로 동시에 실행하는 것

📖 14.2 코틀린의 동시성 처리 방법: 일시 중단 함수와 코루틴

코루틴은 비동기적으로 실행되는 넌블로킹 동시성 코드를 우아하게 작성할 수 있게 해준다.
스레드에 비해 매우 가볍다.
동시성 작업과 생명주기 관리 기능 제공

📖 14.3 스레드와 코루틴 비교

JVM에서 병렬 프로그래밍과 동시성 프로그래밍을 위한 고전적인 추상화는 스레드를 사용하는

fun main() {
    println("I'm on ${Thread.currentThread().name}")
    thread {
        println("And I'm on ${Thread.currentThread().name}")
    }
}

스레드는 애플리케이션을 더 반응성 있게 만들어주고, 멀티코어 CPU의 여러 코어에 작업을 분산시켜 현대적 시스템을 더 효율적으로 사용할 수 있게 해준다.
스레드 간 전환은 운영체제 커널 수준에서 실행되는 작업
스레드가 어떤 작업이 완료되길 기다리는 동안에는 블록된다.
스레드는 기본적으로 독립적인 프로세스로 존재하기 때문에 작업을 관리하고 조정하는 데 어려움이 있을 수 있다.

코틀린은 스레드에 대한 대안으로 코루틴이라는 추상화를 도입

코루틴은 초경량 추상화다.
코루틴은 시스템 자원을 블록시키지 않고 실행을 일시 중단할 수 있으며, 중단 지점에서 재개할 수 있다.
코루틴은 구조화된 동시성이라는 개념을 통해 동시 작업의 구조와 계층을 확립하며, 취소 및 오류 처리를 위한 메커니즘 제공
코루틴은 하나 이상의 JVM 스레드에서 실행

📖 14.4 잠시 멈출 수 있는 함수: 일시 중단 함수

코틀린 코루틴이 스레드, 반응형 스트림, 콜백과 같은 다른 동시성 접근 방식과 다른 핵심 속성으로는 상단수의 경우 코드 형태를 크게 변경할 필요가 없다는 점이 있다.

🔖 14.4.1 일시 중단 함수를 사용한 코드는 순차적으로 보인다

fun login(credentials: Credentials): UserID
fun loadUserData(userID: UserID): UserData
fun showData(data: UserData)

fun showUserInfo(credentials: Credentials) {
    val userID = login(credentials)
    val userData = loadUserData(userID)
    showData(userData)
}

블록된 스레드는 자원을 낭비

suspend fun login(credentials: Credentials): UserID
suspend fun loadUserData(userID: UserID): UserData
fun showData(data: UserData)

fun showUserInfo(credentials: Credentials) {
    val userID = login(credentials)
    val userData = loadUserData(userID)
    showData(userData)
}

suspend 변경자는 함수가 실행을 잠시 멈출 수도 있다는 뜻
- ex) 네트워크 응답을 기다리는 경우 실행을 일시 중단
일시 중단은 기저 스레드를 블록시키지 않는다.
물론 login과 loadUserData의 구현도 코틀린 코루틴을 고려해 작성돼야 한다.

📖 14.5 코루틴을 다른 접근 방법과 비교

fun loginAsync(credentials: Credentials, callback: (UserID) -> Unit) {}
fun loadUserDataAsync(userID: UserID, callback: (UserData) -> Unit) {}
fun showData(data: UserData) {}

fun showUserInfo(credentials: Credentials) {
    loginAsync(credentials) { userID ->
        loadUserDataAsync(userID) { userData ->
            showData(userData)
        }
    }
}

로직이 커지면 콜백이 중첩된 코드가 돼 가독성이 급격히 떨어진다.
- 콜백 지옥

fun loginAsync(credentials: Credentials): CompletableFuture<UserID>
fun loadUserDataAsync(userID: UserID): CompletableFuture<UserData>
fun showData(data: UserData)

fun showUserInfo(credentials: Credentials) {
    loginAsync(credentials)
        .thenCompose { loadUserDataAsync(it) }
        .thenAccept { showData(it) }
}

CompletableFuture을 사용하면 콜백 지옥을 피할 수 있지만 새로운 연산자의 의미를 배워야 한다.
함수의 반환 타입도 변경해야 한다.

fun login(credentials: Credentials): Single<UserID>
fun loadUserData(userID: UserID): Single<UserData>
fun showData(data: UserData)

fun showUserInfo(credentials: Credentials) {
    login(credentials)
        .flatMap { loadUserData(it) }
        .doOnSuccess { showData(it) }
        .subscribe()
}

반응형 스트림을 통한 구현은 콜백 지옥을 피할 수 있지만 함수 시그니처 변경 및 연산자를 사용해야 한다.

위와 비교해보면 코루틴을 사용하는 접근 방식에서는 함수에 suspend 변경자만 추가하면 된다.

🔖 14.5.1 일시 중단 함수 호출

일시 중단 함수는 실행을 일시 중단할 수 있기 때문에 일반 코드 아무 곳에서나 호출할 수는 ㅇ벗다.
일시 중단 함수 실행을 일시 중단할 수 있는 코드 블록 안에서만 호출할 수 있다.
그런 블록 중 하나가 다른 일시 중단 함수일 수 있다.

suspend fun mySuspendingFunction() {}

fun main() {
    mySuspendingFunction() // error
}

일반적인 일시 중단 코드가 아닌 코드에서 일시 중단 함수를 호출하려고 하면 오류가 발생
main 함수를 suspend로 하면 호출 가능

📖 14.6 코루틴 세계로 들어가기: 코루틴 빌더

코루틴은 일시 중단 가능한 계산의 인스턴스다.
다른 코루틴들과 동시에 실행될 수 있는 코드 블록
스레드와 비슷하지만 코루틴은 함수 실행을 일시 중단하는 데 필요한 메커니즘을 포함하고 있다.
- runBlocking은 블로킹 코드와 일시 중단 함수의 세계를 연결할 때 쓰인다.
- launch는 값을 반환하지 않는 새로운 코루틴을 시작할 때 쓰인다.
- async는 비동기적으로 값을 계산할 때 쓰인다.

🔖 14.6.1 일반 코드에서 코루틴의 세계로: runBlocking

suspend fun doSomethingSlowly() {
    delay(500.milliseconds)
    println("I'm done")
}

fun main() = runBlocking {
    doSomethingSlowly()
}

새 코루틴을 생성하고 실행하며, 해당 코루틴이 완료될 때까지 현재 스레드를 블록시킨다.
runBlocking을 사용할 때는 하나의 스레드를 블로킹한다.
다만, 추가적인 자식 코루틴을 얼마든지 시작할 수 있고, 이들은 다른 스레드를 더 이상 블록시키지 않는다.

🔖 14.6.2 발사 후 망각 코루틴 생성: launch 함수

private var zeroTime = System.currentTimeMillis()
fun log(message: Any?) =
    println("${System.currentTimeMillis() - zeroTime} " + "[${Thread.currentThread().name}] $message")

fun main() = runBlocking {
    log("The first, parent, coroutine starts")
    launch {
        log("The second coroutine starts and is ready to be suspended")
        delay(100.milliseconds)
        log("The second coroutine is resumed")
    }
    launch {
        log("The third coroutine can run in the meantime")
    }
    log("The first coroutine has launched two more coroutines")
}

이 예제를 실행하면 아래와 같은 결과가 출력된다.
- -Dkotlinx.coroutines.debug JVM 옵션 포함 실행

38 [main @coroutine#1] The first, parent, coroutine starts
52 [main @coroutine#1] The first coroutine has launched two more coroutines
53 [main @coroutine#2] The second coroutine starts and is ready to be suspended
58 [main @coroutine#3] The third coroutine can run in the meantime
163 [main @coroutine#2] The second coroutine is resumed

병렬성 없이 교차 실행되는 경우다. 즉, 모든 코루틴이 같은 스레드에서 실행
launch를 사용해 새로운 기본 코루틴을 시작할 수 잇다.

🔖 14.6.3 대기 가능한 연산: async 빌더

suspend fun slowlyAddNumbers(a: Int, b: Int): Int {
    log("Waiting a bit before calculating $a + $b")
    delay(100.milliseconds * a)
    return a + b
}

fun main() = runBlocking {
    log("Starting the async computation")
    val myFirstDeferred = async { slowlyAddNumbers(2, 2) }
    val mySecondDeferred = async { slowlyAddNumbers(4, 4) }
    log("Waiting for the deferred value to be available")
    log("The first result: ${myFirstDeferred.await()}")
    log("The second result: ${mySecondDeferred.await()}")
}

이 예제를 실행하면 아래와 같은 결과가 출력된다.

44 [main @coroutine#1] Starting the async computation
60 [main @coroutine#1] Waiting for the deferred value to be available
65 [main @coroutine#2] Waiting a bit before calculating 2 + 2
71 [main @coroutine#3] Waiting a bit before calculating 4 + 4
287 [main @coroutine#1] The first result: 4
481 [main @coroutine#1] The second result: 8

async를 호출할 때마다 새로운 코루틴을 시작함으로써 두 계산이 동시에 일어나게 했다.
await를 호출하면 그 Deferred에서 결괏값이 사용 가능해질 때까지 루트 코루틴이 일시 중단된다.
Deferred 객체는 아직 사용할 수 없는 값을 나타낸다.
- 매래에 언젠가는 값을 알게 될 것이라는 약속, 연기된 계산 결괏값을 나타낸다.

빌더	반환값	쓰임새
`runBlocking`	람다가 계산한 값	블로킹 코드와 넌블로킹 코드 사이를 연결
`launch`	`Job`	발사 후 망각 코루틴 시작(부수 효과가 있음)
`async`	`Deferred<T>`	값을 비동기로 계산(값을 기다릴 수 있음)

📖 14.7 어디서 코드를 실행할지 정하기: 디스패처

코루틴의 디스패처는 코루틴을 실행할 스레드를 결정
디스패처를 선택함으로써 코루틴을 특정 스레드로 제한하거나 스레드 풀에 분산시킬 수 있으며, 코루틴이 한 스레드에서만 실행될지 여러 스레드에서 실행될지 결정할 수 있다.

🔖 14.7.1 디스패처 선택

코루틴은 기본적으로 부모 코루틴에서 디스패처를 상속받으므로 모든 코루틴에 대해 명시적으로 디스패처를 지정할 필요는 없다.

🛠️ 다중 스레드를 사용하는 범용 디스패처: Dispatchers.Default

가장 일반적인 디스패처
CPU 코어 수만큼의 스레드로 구성된 스레드 풀을 기반으로 함
여러 스레드에서 코루틴이 분산돼 실행

🛠️ UI 스레드에서 실행: Dispatchers.Main

UI 프레임워크를 사용할 때는 특정 작업을 UI 스레드나 메인 스레드라고 불리는 특정 스레드에서 실행해야 될 때가 있다.
Dispatchers.Main의 실제 값은 사용하는 프레임워크에 따라 다르다.

🛠️ 블로킹되는 IO 작업 처리: Dispatchers.IO

서드파티 라이브러리를 사용할 때 코루틴을 염두에 두고 설계된 API를 선택할 수 없는 경우
Dispatchers.IO에서 실행된 코루틴은 자동으로 확장되는 스레드 풀에서 실행
CPU 집약적이지 않은 작업(블로킹 API 응답 대기)에 적합

디스패처	스레드 개수	쓰임새
`Dispatchers.Default`	CPU 코어 수	일반적인 연산, CPU 집약적인 작업
`Dispatchers.Main`	1	UI 프레임워크의 맥락에서만 작업
`Dispatchers.IO`	64 + CPU 코어 개수(단, 최대 64개만 병렬 실행)	블로킹 IO 작업, 네트워크 작업, 파일 작업
`Dispatchers.Unconfined`	아무 스레드나	즉시 스케줄링해야 하는 특별한 경우
`limitedParallelism(n)`	커스텀(n)	커스텀 시나리오

🔖 14.7.2 코루틴 빌더에 디스패처 전달

fun main() {
    runBlocking {
        log("Doing some work")
        launch(Dispatchers.Default) {
            log("Doing some background work")
        }
    }
}

코루틴 빌더 함수는 코루틴 디스패처를 명시적으로 지정할 수 있게 한다.
위 코드의 실행 결과는 아래와 같다.

45 [main @coroutine#1] Doing some work
63 [DefaultDispatcher-worker-2 @coroutine#2] Doing some background work

🔖 14.7.3 withContext를 사용해 코루틴 안에서 디스패처 바꾸기

launch(Dispatchers.Default) {
    val result = performBackgroundOperation()
    withContext(Dispatchers.Main) {
        updateUI(result)
    }
}

이미 실행 중인 코루틴에서 디스패처를 바꿀 때는 withContext 함수에 다른 디스패처를 전달

🔖 14.7.4 코루틴과 디스패처는 스레드 안전성 문제에 대한 마법 같은 해결책이 아니다

fun main() {
    runBlocking {
        launch(Dispatchers.Default) {
            var x = 0
            repeat(10_000) {
                x++
            }
            println(x)
        }
    }
}

코루틴이 종료된 후 x 값은 10000으로 정확하다.
한 코루틴이 임의의 스레드에서 실행되더라도 그 로직이 엄격하게 순차적으로 실행되기 때문

fun main() {
    runBlocking {
        var x = 0
        repeat(10_000) {
            launch(Dispatchers.Default) {
                x++
            }
        }
        delay(1.seconds)
        println(x)
    }
}

카운터 값이 예상보다 낮다.
여러 코루틴이 같은 데이터를 수정하고 있기 때문

fun main() = runBlocking {
    val mutex = Mutex()
    var x = 0
    repeat(10_000) {
        launch(Dispatchers.Default) {
            mutex.withLock {
                x++
            }
        }
    }
    delay(1.seconds)
    println(x)
}

Mutex 잠금을 통해 코드 임계 영역이 한 번에 하나의 코루틴만 실행되게 보장할 수 있다.

📖 14.8 코루틴은 코루틴 콘텍스트에 추가적인 정보를 담고 있다

각 코루틴은 추가적인 문맥 정보를 담고 있는데, 이 문맥은 CoroutineContext라는 형태로 제공
CoroutineContext는 여러 요소로 이뤄진 집합
이 요소 중 하나는 코루틴이 어떤 스레드에서 실행될지를 결정하는 디스패처
CoroutineContext에는 코루틴의 생명주기와 취소를 관리하는 Job 객체 포함
CoroutineContext에는 CoroutineNmae, CoroutineExceptionHandler와 같은 메타데이터도 포함

suspend fun introspect() {
    log(coroutineContext)
}

fun main() {
    runBlocking {
        introspect()
    }
}

위 결과는 아래와 같다.

39 [main @coroutine#1] [CoroutineId(1), "coroutine#1":BlockingCoroutine{Active}@32709393, BlockingEventLoop@3d99d22e]

fun main() {
    runBlocking(Dispatchers.IO + CoroutineName("Coolroutine")) {
        introspect()
    }
}

코루틴 빌더에 인자를 전달하면 자식 코루틴의 콘텍스트에서 해당 요소를 덮어쓴다.

43 [DefaultDispatcher-worker-1 @Coolroutine#1] [CoroutineName(Coolroutine), CoroutineId(1), "Coolroutine#1":BlockingCoroutine{Active}@1be729a6, Dispatchers.IO]