[kotlin/코틀린 코루틴의 정석] 4장. 코루틴 빌더와 Job

코루틴 빌더 함수

• 코루틴을 생성하는 데 사용하는 함수 ex) `launch`, `runBlocking`…
• 코루틴을 만들고 코루틴을 추상화한 Job 객체 생성 → Job 객체로 코루틴의 상태를 추적 및 제어

 

Join을 사용한 코루틴 순차 처리

`join()` : 먼저 처리되어야 하는 코루틴의 실행이 완료될 때까지 호출부의 코루틴을 일시 중단하는 함수

💡 delay 함수
- `Thread.sleep()` 해당 함수가 실행되는 동안 스레드가 블로킹돼 사용할 수 없음
- `delay()` 해당 함수가 실행되는 동안 스레드는 다른 코루틴이 사용할 수 있음

Join 함수 사용해 순차 처리하기

fun main() = runBlocking<Unit> {
    val updateTokenJob = launch(Dispatchers.IO) {
        println("[${Thread.currentThread().name}] 토큰 업데이트 시작")
        delay(100L)
        println("[${Thread.currentThread().name}] 토큰 업데이트 완료")
    }
    updateTokenJob.join()
    val networkCallJob = launch(Dispatchers.IO) {
        println("[${Thread.currentThread().name}] 네트워크 요청")
    }
}

• `join()` 의 대상 코루틴이 완료될 때까지 일시 중단 됨 → `join()` 은 일시 중단이 가능한 지점(코루틴 등)에서만 호출 가능

 

JoinAll을 사용한 코루틴 순차 처리

`joinAll()` 복수의 코루틴의 실행이 모두 끝날 때까지 호출부이 코루틴을 일시 중단

joinAll 함수

public suspend fun joinAll(vararg jobs: Job): Unit = jobs.forEach { it.join() }

• 내부적으로 forEach 를 사용하여 parameter 로 받은 Job들을 각각 join()

joinAll 함수 사용해보기

fun joinAll() = runBlocking<Unit> {
    val convertImageJob1: Job = launch(Dispatchers.Default) {
        Thread.sleep(1000L) //이미지 변환 작업 실행 시간
        println("[${Thread.currentThread().name}] 이미지1 변환 완료")
    }
    val convertImageJob2: Job = launch(Dispatchers.Default) {
        Thread.sleep(1000L) //이미지 변환 작업 실행 시간
        println("[${Thread.currentThread().name}] 이미지2 변환 완료")
    }

    joinAll(convertImageJob1, convertImageJob2)

    val uploadImageJob = launch(Dispatchers.IO) {
        println("[${Thread.currentThread().name}] 이미지1,2 업로드")    
    }
}

메인 스레드 (`runBlocking`) 처리 순서

1. `Dispatcher.Default` 스레드 풀에 covertImageJob1 실행 요청
2. `Dispatcher.Default` 스레드 풀에 covertImageJob2 실행 요청
3. `joinAll()`호출 → Job1, Job2가 실행 완료될 때까지 일시 중단
4. Job1, Job2가 모두 완료되면 `runBlocking` 코루틴 재게

 

CoroutineStart.LAZY 사용해 코루틴 지연 시작하기

• 코루틴을 먼저 생성해 놓고 나중에 실행해야 하는 경우에 사용

fun coroutineStartLazy() = runBlocking<Unit> {
    val startTime = System.currentTimeMillis()
    val lazyJob: Job = launch(start = CoroutineStart.LAZY) {
        println("[${getElapsedTime(startTime)}] 지연 실행")
    }
    delay(1000L)
    lazyJob.start()
}
/*
[지난 시간: 1012ms] 지연 실행
*/

• 생성 후 자동으로 실행되지 않으며, `start()` 를 사용하여 직접 실행을 요청해야 함

 

코루틴 취소하기

• 코루틴이 실행될 필요가 없어졌을 경우 애플리케이션의 성능 저하를 방지하기 위해 즉시 취소해야 함
• → 한정적인 리소스를 의미 없는 작업에 사용하는 것이기 때문

cancel 사용해 Job 취소하기

fun cancel() = runBlocking<Unit> {
    val startTime = System.currentTimeMillis()
    val longJob: Job = launch(Dispatchers.Default) {
        repeat(10) { repeatTime ->
            delay(1000L)
            println("[${getElapsedTime(startTime)}] 반복 횟수 ${repeatTime}")
        }
    }
    delay(3500L)
    longJob.cancel()
}
/*
[지난 시간: 1010ms] 반복 횟수 0
[지난 시간: 2027ms] 반복 횟수 1
[지난 시간: 3032ms] 반복 횟수 2

Process finished with exit code 0
*/

`cancel()`

• Job 객체 내부의 취소 확인용 플래그를 ‘취소 요청됨’으로 변경 → 즉시 취소되는 것은 아님
• 이후 미래의 어느 시점에 코루틴의 취소가 요청됐는지 체크 후 취소

cancelAndJoin을 사용한 순차 처리

• `cancelAndJoin()` : 취소에 대한 순차성을 보장
  • 코루틴의 취소가 완료될 때까지 호출부의 코루틴이 일시 중단

fun cancelAndJoin() = runBlocking<Unit> {
    val startTime = System.currentTimeMillis()
    val longJob: Job = launch(Dispatchers.Default) {
        repeat(10) { repeatTime ->
            delay(1000L)
            println("[${getElapsedTime(startTime)}] 반복 횟수 ${repeatTime}")
        }
    }
    delay(3500L)
    longJob.cancelAndJoin()
    println("[${getElapsedTime(startTime)}] 취소 후 작업")
}

/*
[지난 시간: 1013ms] 반복 횟수 0
[지난 시간: 2032ms] 반복 횟수 1
[지난 시간: 3041ms] 반복 횟수 2
[지난 시간: 3556ms] 취소 후 작업

Process finished with exit code 0
*/

 

코루틴의 취소 확인

• `cancel()` , `cancelAndJoin()`
  • Job 객체 내부에 있는 취소 확인용 플래그를 바꾸며, 코루틴이 이 플래그를 확인하는 시점에 비로소 취소
  • 만약 코루틴이 취소를 확인할 수 있는 시점이 없다면 취소는 일어나지 않음
    • while문 내부에 일시 중단 지점이 없기 때문에 일시 중단이 일어날 수 없음

fun cancelNotWorking() = runBlocking<Unit> {
    val startTime = System.currentTimeMillis()
    val whileJob: Job = launch(Dispatchers.Default) {
        while (true) {
            println("작업 중...")
        }
    }
    delay(100L)
    whileJob.cancel()
}
/*
종료되지 않음!
*/

💡 일시 중단 지점, 코루틴이 실행을 대기하는 시점에 코루틴이 취소를 확인

코루틴이 취소 되도록 만드는 방법

1. `delay` 를 사용한 취소 확인
2. `yield` 를 사용한 취소 확인
3. `CoroutineScope.isActive` 를 사용한 취소 확인

delay를 사용한 취소 확인

`delay()`

• 일시 중단 함수(suspend fun)
• 특정 시간만큼 호출부의 코루틴을 일시 중단하게 만듬
• 불필요하게 작업을 지연시켜 성능 저하가 일어남

yield를 사용한 취소 확인

`yield()`

• 자신이 사용하던 스레드를 양보
• 스레드 사용이 양보되면서 일시 중단 → 비효율

CoroutineScope.isActive를 사용한 취소 확인

• 취소가 요청되면 `isActive` 프로퍼티의 값이 `false` 로 바뀜
• 스레드를 일시 중단하거나, 양보하지 않으면서 계속 작업 가능

 

코루틴의 상태와 Job의 상태 변수

• 생성(New) : 코루틴 빌더를 통해 코루틴을 생성하면 기본적으로 생성 상태에 놓이며, 자동으로 실행 중 상태로 넘어감
• 실행중(Active): 코루틴이 실제로 실행 중일 때뿐만 아니라 실행된 후에 일시 중단된 상태
• 실행 완료(Completed): 코루틴의 모든 코드가 실행 완료된 상태
• 취소 중(Cancelling): 코루틴에 취소가 요청된 상태 → 아직 취소가 된 상태는 아니므로 코루틴은 계속해서 실행됨
• 취소 완료(Cancelled): 코루틴의 취소 확인 시점에 취소가 확인된 상태 → 더 이상 실행되지 않음

코루틴 상태	isActive	isCancelled	isCompleted
생성	false	false	false
실행 중	true	false	false
실행 완료	false	false	true
취소 중	false	true	false
취소 완료	false	true	true

---

http://www.acornpub.co.kr/book/kotlin-coroutines

코틀린 코루틴의 정석

🌟후기🌟

Spring Boot - Kotlin 사용하는 환경에서 코루틴에 대한 더 깊은 지식이 필요해 찾다 발견한 책. 
한국인 저자 분이어서 그런지 전반적으로 이해하기 굉장히 쉽게 되어있고,
기존 코틀린 책에서는 쉽게 다뤄지지 않는 더 딥한 코루틴 기능까지 알 수 있음.
(지금까지 읽은 기술서 중 실무에서 가장 잘 쓰고 있는 책...가장 술술 읽힌 책...👍)
SpringBoot-Kotlin 환경에서 코루틴을 더 공부하고 싶다면 정말 강추 필수 필수 👍🔥👍🔥👍🔥👍🔥👍🔥