[Coroutine] Job과 Child 코루틴

💡 구조화된 동시성에 이어서 Job과 child 코루틴의 특징에 대하여 학습하였습니다.

Coroutine Job?

• Job은 코루틴을 취소하고, 상태를 파악하는 등 다양하게 사용될 수 있는 컨텍스트입니다.
• 수명주기를 가지며 인터페이스 입니다.
• 구체적인 사용법과 상태를 가지고 있다는 점에서 추상 클래스처럼 다룰 수 있습니다.

Coroutine Job 상태 도식도

• 아래와 같이 6가지 상태와 도식표로 나타낼 수 있습니다.
• 실제 코드에서는 toString을 활용해 잡의 상태를 볼 수 있습니다.

• Active
  • 잡이 실행되고 코루틴이 잡을 수행합니다.
  • 잡이 코루틴 빌더에 의해 생성되었을 때, 본체가 실행되는 상태이며 자식 코루틴을 시작할 수 있습니다.
• New
  • 대부분 코루틴은 Active 상태로 시작되지만, 지연 시작되는 코루틴은 New 상태로 시작됩니다.
  • New → Active로 전환하려면 작업이 실행되어야 합니다.
• Completing
  • 작업의 실행이 완료되면 변화하는 상태입니다.
• Completed
  • 자식들의 실행이 모두 끝난 상태입니다.
• Cancelling
  • 잡이 실행 도중에 취소되거나 실패하게 되는 상태입니다.
  • 여기서의 도중은 New 상태는 해당하지 않으며, Active나 Complet-ing 상태에서만 올 수 있습니다.
  • 연결을 끊거나 자원을 반납하는 등의 후처리 작업을 진행할 수 있습니다.
• Cancelled
  • 후처리 작업까지 완료되면 도달하는 최종 상태입니다.

코루틴 빌더와 잡의 관계

• 코틀린 코루틴 라이브러리의 모든 코루틴 빌더는 자신만의 잡을 생성합니다.
• 대부분의 코루틴 빌더는 잡을 반환하며, 어느 곳에서든 사용할 수 있습니다.

fun main(): Unit = runBlocking {
    val job : Job = lauch {
        delay(1000)
        prinlnt("Test")
    }
    val deferred : Deferred<String> = async {
        delay(1000)
        "Test"
    }
    val job : Job = deferred
}

• launch의 명시적 반환 타입은 Job이며, async 함수에 의해 반환되는 함수는 Defferred<T>로 이 또한 Job 인터페이스를 구현하고 있습니다.
• 또한 Job은 코루틴 컨텍스트이므로 coroutineContext[Job]을 사용해 접근하는 것도 가능합니다.
  • 이는 확장 프로퍼티를 활용하는 것도 가능합니다.

val CoroutineContext.job: Job
    get() = get(Job) ?: error("Current context donsn't")

fun main(): Unit = runBlocking {
    print(coroutineContext.job.isActive) // true
}

• 잡은 부모 - 자식 관계가 있기 때문에 코루틴 스코프 내에서 취소와 예외 처리 구현이 가능합니다.

fun main(): Unit = runBlocking {
    val job: Job = launch { // 자동으로 부모 잡을 사용
        delay(1000)
    }

    val parentJob: Job = coroutineContext.job // coroutineContext[Job]
    println(job == parentJob) // false
    val parentChildren: Sequence<Job> = parentJob.children
    println(parentChildren.first() == job) // true 
}

• 새로운 Job 컨텍스트가 부모의 잡을 대체하면 구조화된 동시성이 유효하지 않습니다.

fun main(): Unit = runBlocking {
    launch(Job()) { // 부모잡을 사용하지 않고 새로 생성
        delay(1000)
        println("print?")
    }
}
// 아무것도 출력되지 않고 종료됩니다.

• 위 코드에서는 부모 자식 사이에 아무런 관계가 없기 때문에 부모가 자식 코루틴을 기다리지 않습니다.
• 자식을 인자로 들어온 잡을 부모로 사용하기 때문에 runBlocking과 아무련 관련이 없게 됩니다.
• 코투틴이 자신만의 독자적인 잡을 가지고 있으면 부모와 아무련 관련이 없으며, 구조화된 동시성을 잃게 됩니다.

자식들 기다리기

• 잡의 가장 중요한 이점은 코루틴이 완료될 때까지 기다리는 데 사용할 수 있다는 점입니다.
• 이를 위해서 join 메서드를 활용합니다.
• join은 지정한 잡이 Completed나 Cancelled와 같은 마지막 상태에 도달할 때까지 기다리는 중단 함수입니다.

fun main(): Unit = runBlocking {
    val job1 = launch {
        delay(1000)
        print("Test1")
    }
    val job2 = lauch {
        delay(1000)
        print("Test2")
    }

    job1.join()
    job2.join()
    print("all done")
}
// 1초 후 .. Test1
// 1초 후 .. Test2
// all done

• Job 인터페이스는 모든 자식을 참조할 수 있는 children 프로퍼티를 노출시킵니다.
  • 이를 활용해서 모든 자식이 마지막 상태가 될 때까지 기다릴 수 있습니다.

val children = coroutineContext[Job]?.children

잡 팩토리 함수

• Job() 팩토리 함수를 사용하면 코루틴 없이도 Job을 생성할 수 있습니다.
• 어떤 코루틴과도 연관되지 않으며, 컨텍스트로 사용할 수 있습니다.
  • 이는 한 개 이상의 자식 코루틴을 가진 부모 잡으로 사용할 수도 있습니다.
  • 흔한 실수 중 하나는 Job() 팩토리 함수를 사용해 잡을 생성하고, 다른 코투린의 부모로 지정한 뒤에 join을 호출하는 것입니다.
    • 이는 자식 코루틴이 모두 작업을 끝마쳐도 Job이 여전히 액티브 상태에 있기 때문에 프로그램이 종료되지 않습니다.

suspend fun main() : Unit = coroutineScope {
    val job = Job()
    launch(job) { // 새로운 잡이 부모로부투어 상속받은 잡을 대체 
        delay(1000)
        println("print")
    }
    launch(job) { // 새로운 잡이 부모로부투어 상속받은 잡을 대체 
        delay(2000)
        println("print2")
    }
    job.join()
    println("end?")
}
// 1초 후 .. print
// 1초 후 .. print2
// 영원히 실행

• 따라서 잡의 모든 자식 코루틴에서 join을 호출하는 것이 바람직한 방법입니다.

job.children.forEach{ it.join() }

CompletableJob

• Job의 하위 인터페이스로, 아래의 두 가지 메서드를 가집니다.
• complete() : Boolean
  • 잡을 완료하는 데 사용하며, 모든 자식 코루틴은 작업이 완료될 때까지 실행 상태를 유지하지만, complete를 호출한 잡에서 새로운 코루틴이 시작될 수는 없습니다.
  • 잡이 완료되면 실행 결과는 true, 그렇지 않을 경우 false가 됩니다.

fun main() = runBlocking {
    val job = Job()

    launch(job) {
        repeat(3) { num ->
            delay(200)
            println("Rep$num")
        }
    }

    launch {
        delay(500)
        job.complete()
    }

    job.join()

    launch(job){ // job이 완료되었기 때문에, 새로운 코루틴을 시작하지 않음
        println("print")
    }

    println("Done")
}

// Rep0
// Rep1
// Rep2
// Done

• completeExceptionally(exception: Throwable): Boolean
  • 인자로 받은 예외로 잡을 완료시킵니다.
  • 모든 자식 코루틴은 주어진 예외를 래핑한 CancellationException으로 즉시 취소됩니다.

fun main() = runBlocking {
    val job = Job()

    launch(job) {
        repeat(3) { num ->
            delay(200)
            println("Rep$num")
        }
    }

    launch {
        delay(500)
        job.completeExceptionally(Error("error"))
    }

    job.join()

    launch(job){
        println("print")
    }

    println("Done")
}

// Rep0
// Rep1
// Done

• 500초에 completeExceptionally()를 발생시켰으므로 Rep2는 출력되지 않습니다.