About Coroutines

Coroutine (코루틴)

https://www.kodeco.com/34262147-kotlin-coroutines-tutorial-for-android-advanced

What Are Coroutines? 😊

쓰레드를 멈추지 않고 비동기적으로 코루틴 스코프 내에서 지정해준 역할을 수행함.

Coroutines Builder

Coroutines Builder

새 코루틴을 시작하고 실행하려면 코루틴 빌더를 사용해야 합니다. 그들은 일부 코드를 가져와 코루틴으로 래핑하여 실행을 위해 시스템에 전달합니다.

즉시 실행 (launch)

코루틴의 기본 빌더는 launch() 입니다. 새 코루틴을 생성하고 기본적으로 즉시 실행합니다. 일부 CoroutineScope 컨텍스트에서 코루틴을 빌드하고 시작합니다.

GlobalScope.launch { // CoroutineScope
  // coroutine body
}

동시 실행 (Async)

중첩된 코루틴을 시작하는 기타 일시 중지 가능한 함수에서 Coroutines Builder를 사용할 수 있습니다.

동시 실행
또 다른 코루틴 빌더는 async(). 코루틴에서 값을 반환하는 데 사용할 수 있기 때문에 특별합니다. 이렇게 하면 동시 실행이 가능합니다. async()다음과 같이 모든 코루틴에서 사용할 수 있습니다 .

GlobalScope.launch { // CoroutineScope 
  val someValue = async { getValue() } // 코루틴에서 계산된 값 
}

그러나 아직 값을 사용할 수 없습니다. 비차단 취소 가능 퓨처인 async()a를 반환합니다 . Deferred 결과를 얻으려면 를 호출해야 합니다 await(). 기다리기 시작하면 계산된 값을 얻을 때까지 래핑 코루틴을 일시 중지합니다.

블로킹 빌더 (runBlocking)

약간 색다른 코루틴용 다른 빌더를 사용할 수 있습니다. runBlocking() 코루틴이 호출을 차단하도록 합니다.

runBlocking 은 메인 기능이나 테스트와 같은 특별한 상황에서 JVM 종료를 피하기 위해 실행이 완료될 때까지 스레드를 차단하는 빌더입니다. 일반 Kotlin 코루틴 코드에서는 사용하지 않아야 합니다.

Kotlin 코루틴을 시작하고 실행하는 방법을 설명하려면 몇 가지 라이브 코드 스니펫을 살펴보는 것이 가장 좋습니다.

Kotlin Playground

import kotlinx.coroutines.*
import java.lang.Thread

@OptIn(DelicateCoroutinesApi::class)
fun main() {
  GlobalScope.launch {  // launch new coroutine in background and continue
    delay(1000L) // non-blocking delay for 1 second (default time unit is ms)
    println("World!") // print after delay
    val sum1 = async { // non blocking sum1
      delay(100L)
      2 + 2
    }
    val sum2 = async { // non blocking sum2
      delay(500L)
      3 + 3
    }
    println("waiting concurrent sums")
    val total = sum1.await() + sum2.await() // execution stops until both sums are calculated
    println("Total is: $total")
  }
  println("Hello,")     // main thread continues while coroutine executes
  Thread.sleep(2000L)   // block main thread for 2 seconds to keep JVM alive
}

console을 확인해보면

Hello,
World!
waiting concurrent sums
Total is: 10

이와 같이 나오게됩니다.

delay() 위의 스니펫 은 1초 동안 기능을 일시 중단 하는 데 사용하는 Kotlin 코루틴을 시작합니다 .

Kotlin 코루틴은 스레드를 차단하지 않으므로 코드는 두 번째 println()명령문 으로 진행하여 1) Hello,.

다음으로 코드는 메인 스레드는 잠자기 때문에 코루틴이 실행을 완료하기 전에 프로그램이 완료되지 않습니다.

코루틴은 두 번째 줄을 실행하고 를 인쇄합니다 2) World!.

그런 다음 두 개의 비동기 코루틴 을 동시에 빌드하고 시작합니다. 마지막으로 두 동시 작업이 모두 완료되면 3) 합계가 출력됩니다.

CoroutineScope

CoroutineScope 코루틴에 바인딩되는 수명 주기 바인딩 구성 요소를 제공하여
새 코루틴을 제한합니다.

모든 코루틴 빌더는 CoroutineScope 유형에 정의된 확장 함수입니다.

Android 앱에서는 CoroutineScope 수명 주기가 잘 정의된 구성 요소를 구현합니다.

구성 요소에는 Activity, Fragment, ViewModel

Job 범위가 취소되면 모든 Kotlin 코루틴이 리소스를 정리하고 취소합니다.

import kotlinx.coroutines.*
import java.lang.Thread

fun main() = runBlocking { // this: CoroutineScope
  launch { 
    delay(200L)
    println("Task from runBlocking")
  }

  coroutineScope { // Creates a new coroutine scope
    val job = launch {
      println("Task from nested launch, this is printed")
      delay(500L) 
      println("Task from nested launch, this won't be printed")
    }

    delay(100L)
    println("Task from first coroutine scope") // Printed before initial launch
    job.cancel() // This cancels nested launch's execution
  }
    
  println("Coroutine scope is over") // This is not printed until nested launch completes/is cancelled
}

Task from nested launch, this is printed
Task from first coroutine scope
Coroutine scope is over
Task from runBlocking

console을 살펴보면 몇 가지를 알 수 있습니다.

첫째, 코루틴을 강제로 차단하므로 이전처럼 프로그램을 휴면(잠자기) 상태로 둘 필요가 없습니다.

• 초기 지연이 있는 새 코루틴을 시작합니다.
• coroutineScope()를 사용하여 새 범위를 만듭니다.
• 그 안에서 코루틴을 시작하여 반환된 작업을 저장합니다.
• 초기 launch()를 지연시키기 때문에 coroutineScope() 완전히 실행될 때까지 실행되지 않습니다.

그러나 coroutineScope() 내에서 작업과 중첩된 코루틴을 저장하고 지연합니다.
지연된 후에 취소하기 때문에 첫 번째 문만 출력하고

궁극적으로 두 번째 출력 전에 취소합니다. 그리고 coroutineScope()가 완료되면

초기 launch()가 지연을 끝내고 실행을 계속할 수 있습니다.

마지막으로 범위가 완료되면 runBlocking()도 완료될 수 있습니다.

이것으로 프로그램이 종료됩니다. 경합 상태나 중단된 리소스 없이

안정적인 코루틴을 구축하려면 이 실행 흐름을 이해하는 것이 중요합니다.

Canceling a Job

이전 섹션에서 코루틴 실행을 취소하는 방법을 살펴보았습니다.
작업은 수명 주기가 있는 취소 가능한 구성 요소임을 이해해야 합니다.

• 작업은 일반적으로 launch()를 호출하여 생성됩니다.
• 생성자 Job()을 사용하여 생성할 수도 있습니다.

다른 작업의 계층 구조 내에서 부모 또는 자식으로 살 수 있습니다.
상위 작업을 취소하면 모든 하위 작업도 취소됩니다.

하위 작업이 실패하거나 취소되면 상위 및 상위 계층 구조도 취소됩니다.
계층이 받는 예외는 물론 CancellationException입니다.

자식이 실패하면 기본적으로 부모와 계층 구조의 다른 모든 자식이 취소됩니다. 때로는 코루틴 실행이 효과적으로 취소될 때까지 기다려야 합니다. 이 경우 job.cancel() 대신 job.cancelAndJoin()을 호출할 수 있습니다.

import java.lang.Thread
import kotlinx.coroutines.*

fun main() = runBlocking {
  val startTime = System.currentTimeMillis()
  val job = launch(Dispatchers.Default) {
    var nextPrintTime = startTime
    var i = 0
    while (isActive) { // cancelable computation loop
      // print a message twice a second
      if (System.currentTimeMillis() >= nextPrintTime) {
        println("I'm sleeping ${i++} ...")
        nextPrintTime += 500L
      }
    }
  }
  delay(1300L) // delay a bit
  println("main: I'm tired of waiting!")
  job.cancelAndJoin() // cancels the job and waits for its completion
  println("main: Now I can quit.")    
}

I'm sleeping 0 ...
I'm sleeping 1 ...
I'm sleeping 2 ...
main: I'm tired of waiting!
main: Now I can quit.

CoroutinesDispatchers

Dispatcher는 코루틴이 실행을 위해 사용하는 스레드 또는 스레드 풀을 결정합니다.
디스패처는 코루틴을 특정 스레드로 제한할 수 있습니다.
스레드 풀로 보낼 수도 있습니다.
흔하지는 않지만 예측할 수 없는 특정 스레딩 규칙 없이 코루틴을 제한 없이 실행할 수 있습니다.

다음은 몇 가지 일반적인 디스패처입니다.

• Dispatchers.Main
  코루틴을 Swing, JavaFX 또는 Android 앱과 같은 UI 기반 프로그램의 기본 스레드로 제한합니다. 이 디스패처는 Gradle 또는 Maven에서 환경별 Main 디스패처 종속성을 추가하지 않으면 작동하지 않는다는 점에 유의해야 합니다.
  UI와 상호작용하는 작업을 실행하기 위해서만 사용해야함

• Dispatchers.Default
  표준 빌더에서 사용하는 기본 디스패처입니다. JVM 스레드의 공유 풀이 지원합니다. CPU 집약적 계산에 이 디스패처를 사용하십시오.
  CPU를 많이 사용하는 작업을 기본 스레드 외부에서 실행하도록 최적화

• Dispatchers.IO
  공유 스레드 풀을 사용하는 I/O 집중 차단 작업에 이 디스패처를 사용합니다.
  디스크 또는 네트워크I/O 작업을 실행하는데 최적화

• Dispatchers.Unconfined
  이 디스패처는 코루틴을 특정 스레드로 제한하지 않습니다. 코루틴은 자신을 호출한 상속된 CoroutineDispatcher에서 실행을 시작하지만 첫 번째 정지 지점까지만 실행됩니다. 일시 중단이 끝나면 호출된 일시 중단 함수에 의해 완전히 결정된 스레드에서 다시 시작됩니다.

import java.lang.Thread
import kotlinx.coroutines.*

@OptIn(DelicateCoroutinesApi::class)
fun main() = runBlocking<Unit> {
  launch { //context of the parent, main runBlocking coroutine
    println("main runBlocking: I'm working in thread ${Thread.currentThread().name}")
  }
  launch(Dispatchers.Unconfined) { //not confined -- will inmediatly run in main thread but not after suspension
    println("Unconfined: I'm working in thread ${Thread.currentThread().name}")
    delay(100L) // delays (suspends) execution 100 ms
    println("Unconfined: I'm working in thread ${Thread.currentThread().name}")
  }
  launch(Dispatchers.Default) { //will get dispatched to DefaultDispatcher 
    println("Default: I'm working in thread ${Thread.currentThread().name}")
  }
  launch(newSingleThreadContext("MyOwnThread")) {// will get its own new thread
    println("newSingleThreadContext: I'm working in thread ${Thread.currentThread().name}")
  }    
}

Unconfined: I'm working in thread main @coroutine#3
Default: I'm working in thread DefaultDispatcher-worker-1 @coroutine#4
main runBlocking: I'm working in thread main @coroutine#2
newSingleThreadContext: I'm working in thread MyOwnThread @coroutine#5
Unconfined: I'm working in thread kotlinx.coroutines.DefaultExecutor @coroutine#3

Handling Exceptions

스레드에서 포착되지 않은 예외가 발생하면 JVM은 스레드에서 UncaughtExceptionHandler를 쿼리합니다. 그런 다음 JVM은 종료 스레드와 포착되지 않은 예외를 전달합니다. 이는 코루틴과 Java 동시성이 동일한 예외 동작을 처리하기 때문에 중요합니다.

코루틴 빌더는 두 가지 예외 범주로 나뉩니다.
첫 번째는 launch()와 같이 자동으로 전파되므로 나쁜 일이 발생하면 곧 알게 될 것입니다. 두 번째는 async()와 같이 사용자가 처리할 예외를 노출합니다. 값을 얻기 위해 await()를 호출할 때까지 전파되지 않습니다.

import java.lang.Thread
import kotlinx.coroutines.*

@OptIn(DelicateCoroutinesApi::class)
fun main() = runBlocking<Unit> {
  // propagating exception to the default Thread.UncaughtExceptionHandler
  val job = GlobalScope.launch {
    // throw AssertionError() -> 주석 ON/OFF Output 확인 !!!
  }

  // blocks thread execution until coroutine completes
  job.join()

  // launches async coroutine but exception is not propagated until await is called
  val deferred = GlobalScope.async(Dispatchers.Default) {
    throw AssertionError()
  }

  //defines a specific handler
  val handler = CoroutineExceptionHandler { _, exception -> 
    println("We caught $exception") 
  }

  // propagating exception using a custom CoroutineExceptionHandler
  GlobalScope.launch(handler) {
    throw AssertionError()
  } 

  // This exception is finally propagated calling await and should be handled by user, eg. with try {} catch {}
  deferred.await() 
}

# 첫번째 줄 주석 풀었을 경우
Exception in thread "DefaultDispatcher-worker-1 @coroutine#2" java.lang.AssertionError
	at FileKt$main$1$job$1.invokeSuspend(File.kt:8)
	at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
	at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:106)
	at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:570)
	at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:749)
	at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:677)
	at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:664)
	Suppressed: kotlinx.coroutines.DiagnosticCoroutineContextException: [CoroutineId(2), "coroutine#2":StandaloneCoroutine{Cancelling}@14d300bf, Dispatchers.Default]
We caught java.lang.AssertionError
Exception in thread "main" java.lang.AssertionError
 at FileKt$main$1$deferred$1.invokeSuspend (File.kt:16) 
 at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith (ContinuationImpl.kt:33) 
 at kotlinx.coroutines.DispatchedTask.run (DispatchedTask.kt:106) 

# 첫번째 줄 주석일 경우

We caught java.lang.AssertionError
Exception in thread "main" java.lang.AssertionError
 at FileKt$main$1$deferred$1.invokeSuspend (File.kt:16) 
 at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith (ContinuationImpl.kt:33) 
 at kotlinx.coroutines.DispatchedTask.run (DispatchedTask.kt:106) 

Handling 잡힌 console을 확인 할 수 있다.

원문