[Kotlin] 코틀린 Coroutine(코루틴)에 대하여 (1) - CoroutineScope와 CoroutineContext 및 기본 사용방법

 

안녕하세요

오늘은 코틀린의 Coroutine에 대하여

포스팅해보려 합니다.

 

Coroutine이란?

프로그래밍에서 하나의 작업 단위를 Routine이라 하는데

각 Routine이 협업(Co)하여 작업을 처리하는 과정을 합치게 되어 Co + Roitine이라 명명하고 있습니다.

Coroutine은 Thread에서 실행되는 작은 Thread라 호칭할 수 있으나 Thread와 같이 자신을 사용할 스택을

따로 생성하는 것이 아니라 객체 단위로 생성됩니다.

 

그렇다면 Thread대신 Coroutine을 굳이 사용하는 이유는 무엇일까요?? 🤔

 

Thread들을 사용하여 Thread간 Context Switching시 오버헤드가 많이 발생할 뿐만 아니라,

Thread가 Task 실행도중 Block이 반복 된다면 Thread 성능을 제대로 활용하지 못하게 되기 때문에

Coroutine을 사용하여 처리를 한다고 합니다.

 

✔️Context Switching이란?

현재 진행하고 있는 Task(Process, Thread)의 상태를 저장하고

다음 진행할 Task의 상태 값을 읽어 적용하는 과정을 말합니다.

참조 : https://nesoy.github.io/articles/2018-11/Context-Switching

Context Switching이란?

 

 

이제는 Coroutine의 사용방법에 대하여 알아보겠습니다.

 

 먼저 Coroutine은 Kotlin 표준 라이브러리가 아니기 때문에 Gradle 파일에 dependency를 추가해주어야 합니다.

build.gradle에 의존성 추가

저 같은 경우는 위 라이브러리를 사용하였지만 아래 링크에서 코루틴 라이브러리를 검색 시 다른 많은 라이브러리들을 찾을 수 있습니다.

코루틴 뿐만 아니라 여러가지 편리한 라이브러리들을 찾아볼 수 있으니 궁굼하신 분들은 한번씩 확인해보시면 좋을 것 같습니다 :)

 

https://mvnrepository.com/

 

우선 Coroutine에는 크게 2가지의 interface가 존재하는데

바로 CoroutineContext , CoroutineScope입니다.

CoroutineContext란?

코루틴 처리를 어떻게 할 것인지에 대한 요소(Element)들의 집합으로 Dispatcher와 Job이 요소들로 존재합니다.

Dispatcher은 Coroutine을 처리할 Thread를 Setting 하고 할당하는 역할을

Job은 생성된 Coroutine을 관리하는 역할을 수행합니다.

 

 

Job객체의 함수들

함수명	설명
start()	현 코루틴의 상태를 알아내어 시작 or 준비/종료
join()	현 코루틴이 끝나기를 기다림
cancel()	현 코루틴을 종료
cancelAndJoin()	현 코루틴을 종료하고 대기
cancelChildren()	현 CoroutineScope내에 작성된 모든 자식 코루틴들을 종료

 

Dispatcher의 종류 및 설명

이름	설명
Dispatcher.Main	안드로이드에서만 존재하는 Dispatcher로 안드로이드 Main Thread(UI Thread)에서만 사용하는 Dispatcher입니다. ✔️ 반드시 UI와 상호작용을 할 시에만 사용해야 합니다.
Dispatcher.IO	입/출력 작업에 특화된 Dispatcher
Dispatcher.Default	CPU 작업량이 많은 작업에 사용되는 Dispatcher (Sorting , 렌더링 등)
Dispatcher.UnConfined	특수한 상황에서 코루틴을 실행할 때 사용 (사용이 권장되지 않음 )

 

CoroutineScope란?

Coroutine Block(Area)을 생성하는 역할을 수행하며 Coroutine이 실행되는 범위를 나타냅니다.

CoroutineScope의 확장 함수인 Coroutine Builder를 통해 많이 사용하며

가장 많이 사용되는 Builder는 async와 launch입니다.

 아래 예제 코드와 함께 설명드리겠습니다.

 

launch 

결과 반환이 필요 없는 작업을 할 때 주로 사용하며 Job객체를 리턴 받아 해당 코루틴을 관리 할 수 있습니다.

/**
	MutableList에 저장된 값들을 모두 더하는 확장 함수
**/

class ExtensionFunctions {
    companion object{
        fun MutableList<Int>.elementSum() : Int {
            var sum = 0
            forEach{
                sum += it
            }
            return sum
        }
    }
}

import com.lee.coroutine.functions.ExtensionFunctions.Companion.elementSum
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch

suspend fun main() {
    buildLaunch()
}

suspend fun buildLaunch() {
    println("${Thread.currentThread().name}시작")
    with(CoroutineScope(Dispatchers.Default)){
        var sum1 = 0
        var sum2 = 0
        var increment = 1
        val jobObj1 = launch{
            sum1 = (1..100).toMutableList().elementSum()
            delay(1000L)
            println("${Thread.currentThread().name}내의 코루틴 ${increment++}종료")
        }

        val jobObj2 = launch {
            sum2 = (1..100).toMutableList().elementSum()
            delay(1000L)
            println("${Thread.currentThread().name}내의 코루틴 ${increment++}종료")
        }

        jobObj1.join()
        jobObj2.join()
        println("두 리스트의 총합은 ${sum1 + sum2}입니다.")
    }
}

suspend 함수에 대해서..

suspend 키워드는 해당 키워드를 선언함으로써 코루틴 객체에서 작업이 끝날 때까지 잠시 함수를 멈출 수 있습니다.

해당 함수가 멈춰 있는 동안 다른 작업이 진행되며 멈춰있던 함수의 작업이 종료되면 다시 함수로 돌아와 다음 처리를 진행합니다.

코루틴에서 멈춤기능을 사용할 때에는 반드시 suspend로 선언해주어야 하며

suspend 함수는 suspend로 선언된 함수 내부 혹은 코루틴 블럭에서만 사용이 가능합니다.

 

위 코드는 1~100의 값을 가지고 있는 2개의 리스트의 합을 더하도록 하는 간단한 프로그램입니다.

 

CoroutineScope를 통해 코루틴을 사용할 블럭을 지정하고 launch를 통해 코루틴을 생성하고 있으며

각 코루틴들은 Job객체로 관리되어 join()을 통해 작업이 끝날 때까지 대기합니다.

 

실행 화면

 

async

결과 반환 값이 있을 때 주로 사용하며 반환 값은 Deferred<T>입니다.

await()를 통해 Deferred에 감싸져 있는 값을 반환받아 사용할 수 있습니다.

 

import com.lee.coroutine.functions.ExtensionFunctions.Companion.elementSum
import kotlinx.coroutines.*

suspend fun main() {
    buildAsync()
}

suspend fun buildAsync() {
    println("${Thread.currentThread().name} 시작")
    with(CoroutineScope(Dispatchers.Default)){
        var increment = 1
        var value1 = 0
        var value2 = 0
        val resultOne : Deferred<Int> = async {
            println("${Thread.currentThread().name}내의 코루틴 ${increment++}종료")
            (1..100).toMutableList().elementSum()
        }

        val resultTwo : Deferred<Int> = async {
            println("${Thread.currentThread().name}내의 코루틴 ${increment++}종료")
            (1..100).toMutableList().elementSum()
        }
        value1 = resultOne.await()
        value2 = resultTwo.await()
        println("두 리스트의 총 합은 ${value1 + value2}입니다.")
    }

}

위 코드의 결과 값은 launch 예제와 같으며

launch 대신 async를 사용하여 값을 리턴 받아 사용하는 코드입니다.

 

위 2가지 함수들 외에도 withContext(CoroutineScope)와 runBlocking()이 존재하며

 

withContext는 async와 마찬가지로 값을 반환하지만 Deferred <T> 타입이 아닌 단순히 T 타입으로 반환합니다.

suspend fun buildWithContext() {
	val value = withContext(Dispatchers.Default){ 
    // 마지막에 반환값을 지정해주면 Deferred로 묶이지 않고 바로 반환된다.
    	(1..100).toMutableList().elementSum()
    }
    println("값은 $value")
}

runBlocking()은 Thread에서 해당 함수가 호출 시  호출된 부분에서 Block 되어 runBlocking() 함수 내부의 

코루틴들이 모두 종료될 때까지 함수를 정지시켜 동기화된 값을 얻고자 할 때 주로 사용합니다.

 

 

 

이상으로 코루틴의 기본 사용방법을 마치겠습니다.

 

다음 포스팅으로는 Coroutine의 Channel과 Flow에 대하여 공부한 내용을 포스팅해보려 합니다. 😊

그럼 다음 포스팅에서 뵙겠습니다.

 

오늘도 즐코하세요 :)