이 글은 Asynchronous Flow(비동기 처리)를 다루지 않습니다.

• 용어 정리
  • 서브 루틴 : 함수와 유사한 기능을 제공하지만 값을 CPU의 레지스터를 이용하지 않고 메모리로 전달한다.
  • 코루틴 : 서브루틴의 확장 개념으로써 로직 중간에 재 시작, 종료, 일시 중지가 가능하다.
  • Dispatchers : 코루틴에서 사용할 스케쥴러를 정의하며, Default(Current Thread), Main(UI Thread) 등을 지정할 수 있다.
  • CoroutineScope : 코루틴의 동작 범위를 지정한다. CoroutineScope는 기본 스케쥴러를 함께 지정해야 한다.
  • launch : 코루틴으로 동작해야 할 코드 범위을 지정한다. 이때 사용할 스케줄러를 함께 지정할 수 있으며, 지정하지 않을 경우 CoroutineScope에서 지정한 스케줄러를 사용한다. 중간에 스케줄러 변경을 위해서도 사용가능하다.
  • Job : launch의 결과로 리턴 받으며 이를 통해 일시 정지, 종료, 취소 , 시작 등의 제어가 가능하다.
  • Deferred : Async의 결과로 리턴받으므로 이 값은 Await() 함수를 호출하지 않으면 코루틴을 실행하지 않는다.
• 기본적인 사용법

val job = GlobalScope.launch(Dispatchers.Default)
{
 println("Coroutine is started..!")
 repeat(10) { //10
 delay(1000L)
 println("I'm working")
 }
}
println("Main is started..!")

runBlocking {
 println("Coroutine is done..!")
}

job.join()

• Suspend 함수
  • 함수를 코루틴 지원 가능한 형태로 변환한다
  • 컴파일 단계에서 이루어진다
  • 함수를 State Machine 형태로 변환한다

suspend fun doSomethingUsefulOne() // 1
: Int {
 delay(1000L)
 return 1
}
suspend fun doSomethingUsefulTwo() // 2
: Int {
 delay(1000L)
 return 2
}
val time = measureTimeMillis //
{
 val one = async { doSomethingUsefulOne() }
 val two = async { doSomethingUsefulTwo() }
 println("The answer is ${one.await() + two.await()}")
}
println("Completed in $time ms")

• 기본 비동기 형태

var deferred: Deferred
var sum = 0
for (i in 1..1_000_00) {
 deferred = GlobalScope.async { i }
 runBlocking { sum += deferred.await() }
}

• suspend 함수 + withContext**( 중간에 실행환경 변경 )**

suspend fun task(numbers : Int) = withContext(Dispatchers.IO) {
 //long running task..
}
suspend fun fetchTwoDocs() =
 coroutineScope {
  val deferredOne = async { task(1) }
  val deferredTwo = async { task(2) }
  deferredOne.await()
  deferredTwo.await()
 }

• Coroutine Context
  • 코루틴에 관한 정보 객체이며 코루틴 디스패처를 포함한다.
  • 모든 코루틴 빌더 launch, async는 코루틴 컨텍스트를 파라미터로 입력받아 사용할 수 있다.

launch(Dispatchers.Unconfined) { // Dispatchers .
 println("Unconfined: I'm working in thread ${Thread.currentThread().name}")
}

• Coroutine Dispatcher
  • 코루틴을 실행하기 위한 스레드 정보 및 실행 스레드 정의를 담당한다.
  • 스레드 설정
    • noArg : 상위 Coroutine Context의 정보에 따라 동작한다.
    • Unconfined : main thread에서 동작시킨다. ( 사실 현재 Thread 위에서 동작시킨다 )
    • Default : GlobalScope.launch와 동일한 동작을 하며, 기본 공유 풀을 사용한다.
    • newSingleThreadContext : 새로운 스레드를 생성하여 동작시킨다.
• Classed Coroutine
  • 특정 클래스에 해당하는 모든 함수가 코루틴 형태를 실행하기 편리하도록 하는 기능

class Activity : CoroutineScope by CoroutineScope(Dispatchers.Default) {
 fun doSomething() {
  repeat(10) { i ->
    launch {
      delay((i + 1) * 200L)
      ... etc
      println("Coroutine $i is done")
    }
  }
 }
}

fun main() = runBlocking<Unit> {
 val activity = Activity()
 activity.doSomething() // run test function
 println("Launched coroutines")
 delay(500L) // delay for half a second
 println("Destroying activity!")
 activity.destroy() // cancels all coroutines
 delay(1000) // visually confirm that they don't work
}

• Utilities for Reactor ( Spring Webflux Base)
  • Mono to coroutine

..coroutine scope
runBlocking {
 val mono //is Mono<T>
 = mono(currentDispatcher() //coroutine Dispatcher) {
 "OK"
 }
 mono.subscribe //Mono {
 value ->
 println(value)
 }
}

• coroutine to Mono<T>

..coroutine scope
runBlocking {
 val job = launch {
 "OK"
 }
 val mono = job.asMono(coroutineContext.minusKey(Job))
 mono.subscribe { value ->
 println(value)
 }
}