[Coroutine] 코루틴 디스패처

💡 RxJava에서의 스케줄러와 비슷한 기능을 하는 코루틴 디스패처에 대하여 학습하였습니다.

 

CoroutineDispatcher

• 코투린 디스패처는 코루틴을 스레드로 보내는 역할을 합니다.
• 모든 작업은 스레드 위에서 실행돼야 하고, 코루틴 또한 작입이므로 스레드 위에서만 실행될 수 있습니다.
• 우리가 코루틴을 만들어 CoroutineDispatcher로 코루틴 실행을 요청하면, CoroutineDispatcher는 자신이 사용할 수 있는 스레드풀의 스레드 중 하나에 코루틴을 보냅니다.

기본 디스패처

• 디스패처를 설정하지 않으면 기본적으로 Dispatchers.Default가 설정됩니다.
• CPU를 많이 사용하는 작업에서 실행합니다.
• 이 디스패처는 코드가 실행되는 컴퓨터의 CPU 개수와 동일한 수(최소 2개 이상)의 스레드 풀을 가지고 있습니다.

suspend fun main() = coroutineScope {
    repeat(1000) {
        launch { //**Dispatchers.Default**
            val threadName = Thread.currentThread().name
            println("Running on thread: $threadName")
        }
    }	****
}
// Running on thread: DefaultDispathcer-worker-1
// Running on thread: DefaultDispathcer-worker-2
// ....

• runBlocking은 디스패처가 설정되지 않으면 자신만의 디스패처를 사용하므로 Dispatchers.Default를 자동으로 선택하지 않습니다.
• 위 에서는 coroutineScope 대신에 runBlocking을 사용하면 모든 코루틴은 main에서 실행됩니다.

디스패처 제한하기

• limitedParallelism을 사용해서 디스패처가 같은 스레드 풀을 사용하지만 같은 시간에 특정 수 이상의 스레드를 사용하지 못하도록 제한할 수 있습니다.

private val dispatcher = Dispatchers
    .Default
    .limitedParallelism(5)

• limitedParallelism은 kotlinx.coroutines 1.6 버전에서 도입되었습니다.

메인 디스패처

• Dispatchers.Main을 통해서 메인 스레드에서 코루틴을 실행할 수 있습니다.
• UI와 상호작용하는 작업을 실행하기 위해서 사용됩니다.
• 메인 스레드가 블로킹되면 전체 애플리케이션이 멈추므로, 조심스럽게 다뤄야 합니다.
• 단위 테스트 시 kotlinx-coroutines-test에서 Dispatchers.setMain(dispatcher)로 디스패처를 설정할 수 있습니다.
• 블로킹 대신 중단하는 라이브러리를 사용하고 복잡한 연산을 하지 않는다면 Dispatchers.Main으로 기본 디스패처를 사용할 수 있습니다.

IO 디스패처

• 디스크 또는 네트워크 I/O 작업을 실행하는데 최적화되어 있습니다.
• IO 디스패처는 시간이 오래 걸리는 작업이나 블로킹 함수가 있는 라이브러리를 사용할 때 필요합니다.
• 어플리케이션을 멈추게 할 수는 없기 때문에 메인 스레드를 블로킹하지 않고, IO 디스패처를 활용할 수 있습니다.

suspend fun main() {
    val time = measureTimeMillis {
        coroutineScope {
            repeat(50) {
                launch(Dispatchers.IO) {
                    Thread.sleep(1000)
                }
            }
        }
    }
    print(time) // ~ 1000
}

• Dispathcers.Default와 Dispathcers.IO는 같은 스레드 풀을 공유합니다.
  • 스레드는 재사용되고 다시 배분될 필요가 없으며, 독립적이기 때문에 다른 디스패처의 스레드를 고갈시키는 경우는 없습니다.

suspend fun main(): Unit = coroutineScope {
    launch(Dispatchers.Default){
        println(Thread.currentThread().name)
        withContext(Dispatchers.IO) {
            println(Thread.currentThead().name)
        }
    }
}
// DefaultDispatcher-worker-2
// DefaultDispatcher-worker-2

• Dispatchers.IO에서 64개의 스레드까지 사용할 수 있고, 8개의 코어를 가지고 있다면 공유 스레드 풀에서 활성화된 스레드는 72개 입니다.

Dispatchers.IO를 사용하는 경우

• 가장 흔한 경우는 라이브러리에서 블로킹 함수를 호출해야 하는 경우입니다.
• 이런 경우 withContext(Dispatchers.IO)로 래핑하여 중단함수를 만드는 것이 가장 좋습니다.

withContext(Dispatchers.IO)

• 반면에 withContext(Dispatchers.IO)로 래핑한 함수가 너무 많은 스레드를 블로킹하면 문제가 될 수 있습니다.
• 이런 경우 limitedParallelism을 활용할 수 있습니다.

커스텀 스레드 풀을 사용하는 IO 디스패처

• limitedParallelism를 활용하면 독집적인 스레드 풀을 가진 새로운 디스패처를 만듭니다.
• 이렇게 만들어진 풀은 우리가 원하는 만큼 많은 수의 스레드를 설정할 수 있으므로, 스레드 수를 제한하지 않습니다.(64개 이상 활용 가능)
  • 100개의 스레드를 사용할 경우 Dispatchers.IO는 총 2초가 걸립니다. (64개 수행 - 1초, 나머지 36개 수행 - 1초)
  • 반면에 limitedParallelism를 활용하면 100개의 스레드로 1초만에 수행할 수 있습니다.

launch {
    val dispatcher = Dispatchers.IO
        .limitedParalledlism(100)
}

• Dispatchers.Default의 limitedParallelism은 디스패처의 스레드 수 제한을 추가합니다.
• Dispatchers.IO의 limitedParallelism은 Dispatchers.Default와 독립적인 디스패처를 만들지만, 모든 스레드가 무제한인 스레드 풀을 함께 공유합니다.

• 한도를 지정하는 것에 정답은 없지만, 너무 많은 스레드는 자원을 비효율적으로 사용할 수 있습니다.
• 하지만 스레드 수가 너무 적다면 성능상 좋지 않으므로 적절한 배치가 중요합니다.

다양한 디스패처 활용

정해진 수의 스레드 풀을 가진 디스패처

• 몇몇 개발자들은 자신들이 사용하는 스레드 풀을 직접 관리하기 원하며, 자바는 이를 지원하기 위한 강력한 API를 제공하기도 합니다.
• 반면에 이러한 디스패처는 close 함수로 반드시 닫아야 하는 등 개발자가 깜박할 수 있는 이슈가 있으며, 이는 스레드 누수를 일으키는 경우가 발생할 수 있습니다.

싱글스레드로 제한된 디스패처

• 다수의 스레드를 사용하는 모든 디스패처는 공유 상태로 인한 문제를 생각해야합니다.

var i = 0

suspend fun main(): Unit = coroutineScope {
    repeat(10_000) {
        launch(Dispatchers.IO) {
            i++
        }
    }
    delay(1000)
    println(i) // ~9930
}

• i를 1씩 증가시켜 10000을 기대하고 있지만, 실제로는 이보다 작은 값을 가지게 됩니다.
• 그 이유는 동일 시간에 다수의 스레드가 공유 상태(i 프로퍼티)를 변경했기 때문입니다.
• 싱글스레드를 가진 디스패처를 사용하는 방법으로 이 문제를 해결할 수 있습니다.

var i = 0

suspend fun main(): Unit = coroutineScope {
    val dispatcher = Dispatchers.Default
        .limitedParalledlism(1)

    repeat(10_000) {
        launch(dispatcher) {
            i++
        }
    }
    delay(1000)
    println(i) // 10000
}

• 하지만 단 하나의 스레드만 가지고 있기 때문에 이 스레드가 블로킹되면 작업이 순차적으로 처리되는 단점을 가지고 있습니다.

제한받지 않는 디스패처

• Dispatchers.Unconfined를 활용해 제한받지 않는 디스패처를 활용할 수 있습니다.
• 호출 스레드에서 코루틴을 시작하지만 이는 첫번째 중단점을 만날때 까지만 실행됩니다.
• 중단점 이후 코루틴이 재개될 때는 중단 함수를 재개한 스레드에서 수행됩니다.
• 코루틴이 CPU 시간을 소모하지 않거나, 공유되는 데이터를 업데이트 하지 않는 경우처럼 특정 스레드에 국한된 작업이 아닌 경우 사용합니다.
• 또한 단위 테스트에 유용하게 활용할 수 있습니다.
  • launch를 호출하는 함수를 테스트하는 경우 시간을 동기화할 수 있습니다.

메인 디스패처로 즉시 옮기기

• 코루틴을 배정하는 것에도 비용이 들며, withContext가 호출되면 코루틴은 중단되고 큐에서 기다리다가 재개됩니다.
• 스레드에서 이미 실행되고 있는 코루틴을 다시 배정하면 작지만 필요 없는 비용이 들 수 있습니다.

suspend fun showUser(user: User) =
    withContext(Dispatchers.Main.immediate) {
        userNameElement.text = user.name
    }

• Dispatchers.Main.immediate를 활용해 필요한 경우에만 배정할 수 있습니다.

요약

• 디스패처는 코루틴이 실행될 스레드나 스레드 풀을 결정합니다.
• Dispatchers.Default는 CPU 집약적인 연산에 사용합니다.
• Dispatchers.Main은 Android, Swing, JavaFX에서 메인 스레드에 접근할 때 사용합니다.
• Dispatchers.Main.immediate는 Dispatchers.Main이 사용하는 스레드에서 실행되지만 꼭 필요할 때만 재배정됩니다.
• Dispatchers.IO는 블로킹 연산을 할 필요가 있을 때 사용합니다.
• Dispatchers.Unconfined는 코루틴이 실행될 스레드에 대해서 신경 쓸 필요가 없을 때 사용합니다.

참고

https://medium.com/@sahilthakar10/dispatchers-io-and-default-under-the-hood-b39aee24d2e9