Coroutine Cancellation and timeouts

https://kotlinlang.org/docs/cancellation-and-timeouts.html

Cancellation and timeouts | Kotlin

위 링크를 공부하며 남기는 기록이다.

 

Coroutine cancellation

이전에 Job을 취소할 수 있다고 적었다.

val job = launch {
    repeat(1000) { i ->
        println("job: I'm sleeping $i ...")
        delay(500L)
    }
}
delay(1300L) // delay a bit
println("main: I'm tired of waiting!")
job.cancel() // cancels the job
job.join() // waits for job's completion 
println("main: Now I can quit.")

@kotlin.internal.InlineOnly
public inline fun repeat(times: Int, action: (Int) -> Unit) {
	contract { callsInPlcase(action) }
	
	for (index in 0 until times) {
		action(index)
	}
}

repeat부터 보면 인라인 함수로 람다구문을 times만큼 반복한다. 위에서는 1000번 반복된다. 500ms딜레이와 함께 문자열이 출력되고 이게 계속 반복된다. job과 동시에 밖 스코프에서도 딜레이가 있는데 밖은 1300ms이다. 그러면 결과적으로 repeat안의 문자열이 3번 출력된다. 그리고 3번 출력 후 500ms를 기다리는 사이에 밖 스코프의 문자열이 출력되고 job.cancel()이 호출되면서 실행중이던 job 코루틴을 취소 시킨다. join은 job이 끝날때 까지 기다리는 함수인데 join을 해도 job이 취소돼서 마지막 문자열 출력 전에 다른 문자열을 볼 수 없게된다.

CancellationException

모든 suspend fun은 취소가능하다. 취소되면 CancellationException 예외를 반환 하지만 이 예외를 코루틴 내에서 인지하지 못하면 취소되지않는다.

while (i < 5) { // computation loop, just wastes CPU
            // print a message twice a second
            if (System.currentTimeMillis() >= nextPrintTime) {
                println("job: I'm sleeping ${i++} ...")
                nextPrintTime += 500L
        }
    }

job 내부의 while문이다. 이 구문은 cancel이 호출되도 반복문 연산 중이라서 중간에 중단되지않는다. 반복문이라 눈에 잘 안들어온다면 다음 예시로 더 잘 알 수 있다.

val job = launch(Dispatchers.Default) {
    repeat(5) { i ->
        try {
            // print a message twice a second
            println("job: I'm sleeping $i ...")
            delay(500)
        } catch (e: Exception) {
            // log the exception
            println(e)
        }
    }
}
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.")

맨 처음 코드와 같은 내용이다. cancel과 join을 한번에 해주는 cancelAndJoin 함수가 생겼고  job 코루틴 내부에 try-catch로 예외를 잡는다. 이러면 cancel을 호출했을때 코루틴 내부에서 발생하는 cancellationException을 try-catch문이 처리를 해버려서 취소가 되지않고 아래와 같은 결과를 출력한다. 

job: I'm sleeping 0 ... 
job: I'm sleeping 1 ... 
job: I'm sleeping 2 ... 
main: I'm tired of waiting! 
kotlinx.coroutines.JobCancellationException: StandaloneCoroutine was cancelled; job="coroutine#2":StandaloneCoroutine{Cancelling}@6f3a6402 
job: I'm sleeping 3 ... 
kotlinx.coroutines.JobCancellationException: StandaloneCoroutine was cancelled; job="coroutine#2":StandaloneCoroutine{Cancelling}@6f3a6402 
job: I'm sleeping 4 ... 
kotlinx.coroutines.JobCancellationException: StandaloneCoroutine was cancelled; job="coroutine#2":StandaloneCoroutine{Cancelling}@6f3a6402 
main: Now I can quit.

이런 원치않는 조작을 피하기 위해 반복문 연산의 조건을 isActive로 바꿔주면 바로 해결된다.

while (isActive) { // cancellable computation loop
        // print a message twice a second
        if (System.currentTimeMillis() >= nextPrintTime) {
            println("job: I'm sleeping ${i++} ...")
            nextPrintTime += 500L
        }
    }

isActive 프로퍼티는 job이 completed거나 cancelled가 아닐 때 true를 반환한다. job에 cancel호출됐을때 isActive가 감지해서 false를 반환하고, job이 안전하게 취소된다.

 

try-catch일때 발생하는 문제는 try-finally를 사용하면 더 쉽게 처리가능하다.  

 

withContext

cancel작업중에 해야되는 작업이 있을 수도 있다. 더 안전한 종료를 위해서 임시로 저장한다던가 하는 작업을 하려면 withContext와 NonCancellable을 사용해야한다.

finally {
    withContext(NonCancellable) {
        println("job: I'm running finally")
        delay(1000L)
        println("job: And I've just delayed for 1 sec because I'm non-cancellable")
    }
}

withContext는 코루틴 스코프를 람다로 받는다. 중괄호 안에 있는 작업들은 그래서 코루틴이다. withContext는 context로 부모스코프를 받으며 실행된 코루틴의 결과는 부모 스코프에게 반환된다. 부모 스코프의 context를 받을 때 cancellation exception을 확인하는데 active상태가 아니면 바로 withContext도 cancel 예외를 던진다.

 

또 취소작업을 수행하려면 Dispatcher가 변경될 때만 가능하기때문에 withContext(NonCancellable)과 같이 넣어버리면 취소할 수 없는 작업을 실행시키는 게 된다.

 

withTimeout withTimeoutOrNull

위와 같은 취소작업이 필요한 이유는 시간초과(runtime exceed)의 가능성 때문이다.  취소작업 없이 timeout이 발생하는 경우를 제어하려면 withTimeout이나 withTimeoutOrNull을 이용해야한다.

두 함수역시 suspend fun이고 timeout이라면 TimeoutCancellationException이나 Null(OrNull함수의 경우)을 예외로 던진다.

withTimeout(1300L) {
        repeat(1000) { i ->
            println("I'm sleeping $i ...")
            delay(500L)
        }
    }

val result = withTimeoutOrNull(1300L) {
        repeat(1000) { i ->
            println("I'm sleeping $i ...")
            delay(500L)
        }
        "Done" // will get cancelled before it produces this result
    }
println("Result is $result")

지정한 시간을 넘어가면 예외를 던진다. 두번째는 null을 던지니까 result에는 null이 저장된다.

 

비동기로  timeout을 사용할 때는 리소스제어 문제가 생길 수 있다. timeout이 끝나도 해당 블록에서 사용했던 리소스는 해제되지않기 때문인데 withTimeout이 예외를 던진다는 점을 활용하여 리소스 해제를 안전하게 할 수 있다.

try {
    withTimeout(60) { // Timeout of 60 ms
        delay(50) // Delay for 50 ms
        resource = Resource() // Store a resource to the variable if acquired      
    }
    // We can do something else with the resource here
} finally {  
    resource?.close() // Release the resource if it was acquired
}

 

"댓글, 공감 버튼 한 번씩 누르고 가주시면 큰 힘이 됩니다"