suspend ?

일시 중단 함수

이름이나 아이디를 기준으로 프로파일을 검색하는 클라이언트 인터페이스를 설계해보자. 비동기 함수를 갖도록 구현하기 위해 Deferred를 반환하도록 하자

interface ProfileServiceRepository {
		fun asyncFetchByName(name: String) : Deferred<Profile>
		fun asyncFetchbyId(id: Long) : Deferred<Profile>
}

모의 구현은 간단하다.

class ProfileServiceClient : ProfileServiceRepository {
		override fun asyncFetchByName(name: String) = GlobalScope.async {
				Profile(1, name, 28)
		}
		fun asyncFetchbyId(id: Long) : GlobalScope.async {
				Profile(id, "Susan", 28)
		}
}

이 구현을 호출해보자.

fun main(args: Array<String>) = runBlocking {
		val client : ProfileServiceRepository = ProfileServiceClient()
		val profile = client.asyncFetchById(12).await()

		println(profile)
}

구현에서 관찰할 수 있는 몇 가지 사항이 있다.

• 함수 이름이 이해하기 편히하게 돼 있다. 필요할 때 클라이언트가 진행하는 것을 완료할 때까지 대기해야 한다는 것을 알 수 있도록, 함수가 비동기(async)라는 점을 명시하는 것이 중요하다.

• 호출자는 항상 요청이 완료될 때까지 일시정지해야 하므로 보통 함수 호출 직후에 await() 호출이 있게 된다.

• 구현은 Deferred와 엮이게 될 것이다. 다른 유형의 퓨처(feture)로 ProfileServiceRepository 인터페이스를 깔끔하게 구현하기 위한 방법은 없다. 코틀린이 아닌 동시성 기본형으로 구현하면 자칫 지저분해질 수 있다.

일시 중단 함수로 업그레이드

일시 중단 함수를 사용하기 위해 코드를 리팩토링해보자.

긴 함수 이름 대신 좀더 깔끔한 이름을 가질 수도 있다. 더 중요한 것은 비동기 함수로 구현하도록 강제하는 인터페이스 대신 일시 중단과 Profile를 반환하는 작업에만 신경 쓰면 된다는 것이다. 이제 다음과 같이 Deffered를 제거할 수 있다.

interface ProfileServiceRepository {
		suspend fun fetchByName(name: String) : Profile
		suspend fun fetchById(id: Long) : Profile
}

구현 또한 쉽게 바뀔 수 있다.

class ProfileServiceClient : ProfileServiceRepository {
		override suspend fun fetchByName(name: String) : Profile {
				return Profile(1, name, 28)
		}
		override suspend fun fetchById(name: String) : Profile {
				return Profile(id, "Susan", 28)
		}
}

이 방식은 비동기 구현에 비해 몇 가지 분명한 이점이 있다.

• 유연함 : 인터페이스의 상세 구현 내용은 노출되지 않기 때문에 퓨처를 지원하는 모든 라이브러리를 구현에서 사용할 수 있다.

• 간단함 : 순차적으로 수행하려는 작업에 비동기 함수를 사용하면 항상 await()를 호출해야 하는 번거로움이 생기고, 명시적으로 async가 포함된 함수의 이름을 지정해야 한다.

일시 중단 함수와 비동기 함수

비동기 함수 대신 일시 중단 함수를 사용하기 위한 가이드라인은 다음과 같다.

• 일반적으로 구현에 Job이 엮이는 것을 피하기 위해서는 일시 중단 함수를 사용하는 것이 좋다.

• 인터페이스를 정의할 때는 항상 일시 중단 함수를 사용한다. 비동기 함수를 사용하면 Job을 반환하기 위한 구현을 해야 한다.

• 마찬가지로 추상(abstract) 함수를 정의할 때는 항상 일시 중단 함수를 사용한다. 가시성이 높은 함수일수록 일시 중단 함수를 사용해야 한다.

코루틴 컨텍스트

코루틴은 항상 컨텍스트 안에서 실행된다. 컨텍스트는 코루틴이 어떻게 실행되고 동작해야 하는지를 정의할 수 있게 해주는 요소들의 그룹이다.

디스패처

디스패처(Dispatcher)는 코루틴이 실행될 스레드를 결정하는데, 여기에는 시작될 곳과 중단 후 재개될 곳을 모두 포함된다.

CommonPool

CommonPool은 CPU 바운드 작업을 위해서 프레임워크에 의해 자동으로 생성되는 스레드 풀이다. 스레드 풀의 최대 크기는 시스템의 코어 수에서 1을 뺀 값이다. 현재는 기본 디스패처로 사용된다.

예외 처리

코루틴 컨텍스트의 또 다른 중요한 용도는 예측이 어려운 예외에 대한 동작을 정의하는 것이다. 이러한 유형의 컨텍스트는 다음과 같이 CoroutineExceptionHandler를 구현해 만들 수 있다.

fun main(args: Array<String>) = runBlocking {
		val handler = CoroutineExceptionHandler({ context, throwable ->
				println("Error captured in $context")
				println("Message: ${throwable.message}")
		})

		GlobalScope.launch(handler) {
				TODO("Not implemented yet!")
		}
}

Non-cancellable

앞에서 다룬 것처럼 코루틴의 실행이 취소되면 코루틴 내부에 CancellationException 유형의 예외가 발생하고 코루틴이 종료된다.

suspend fun nonCancellable() {
    val duration = measureTimeMillis {
        val job = GlobalScope.launch {
            try {
                while (isActive) {
                    delay(500)
                    println("still running")
                }
            } finally {
                withContext(NonCancellable) { // NoneCancellable 컨텍스트를 사용하여 코루틴이 취소 되더라도 중지 되지 않는다. 
                    println("cancelled, will delay finalization now")
                    delay(5000)
                    println("delay completed, bye bye")
                }
            }
        }

        delay(1200)
        job.cancelAndJoin()
    }

    println("Took $duration ms")
}

NonCancellable 컨텍스트를 사용하지 않는다면 취소 시 delay가 일어나지 않고 종료되지 않는다. 코루틴이 취소되는 동안 일시 중지가 필요한 경우 NonCancellable 컨텍스트를 사용해야 한다.

컨텍스트에 대한 추가 정보

컨텍스트 결합

컨텍스트의 일부분이 될 수 있는 여러 종류의 요소가 있다. 다양한 요구사항을 만족하는 컨텍스트를 생성하기 위해 이러한 요소들을 결합시킬 수 있다.

컨텍스트 조합

특정 스레드에서 실행하는 코루틴을 실행하고 동시에 해당 스레드를 위한 예외처리를 설정한다고 가정하자.

fun main(args: Array<String>) = runBlocking {
    val dispatcher = newSingleThreadContext("myDispatcher")
    val handler = CoroutineExceptionHandler { _, throwable ->
        println("Error captured")
        println("Message: ${throwable.message}")
    }

    // Combine two contexts together
    val context = dispatcher + handler

    GlobalScope.launch(context) {
        println("Running in ${Thread.currentThread().name}")
        TODO("Not implemented!")
    }.join()
}

컨텍스트 분리

결합된 컨텍스트에서 컨텍스트 요소를 제거할 수도 있다.

fun main(args: Array<String>) = runBlocking {
    val dispatcher = newSingleThreadContext("myDispatcher")
    val handler = CoroutineExceptionHandler { _, throwable ->
        println("Error captured")
        println("Message: ${throwable.message}")
    }

    // Combine two contexts together
    val context = dispatcher + handler

    // Remove one element from the context
    val tmpCtx = context.minusKey(dispatcher.key)

    GlobalScope.launch(tmpCtx) {
        println("Running in ${Thread.currentThread().name}")
        TODO("Not implemented!")
    }.join()
}

요약

• withContext() 일시 중단 코드 정의를 위한 유연한 방법을 제공할 수 있다.

• 비동기 함수(job 구현을 반환하는 함수)는 특정 구현을 강요하는 위험을 피하기 위해 withContext() 공개 API의 일부가 돼서는 안 된다고 언급했다.

• 코루틴 컨텍스트에 대한 흥미로운 주제와 작동하는 방법을 이해해야 한다.

• 디스패처를 시작으로 예외 처리와 취소 불가능한 고유한 컨텍스트로 옮겨가는 다양한 유형의 코루틴 컨텍스트가 존재한다.

• 코루틴에서 기대하는 동작을 얻기 위해 많은 컨텍스트를 하나로 결합할 수 있다.

• 요소 중 하나의 키를 제거함으로써 결합된 컨텍스트를 분리할수 있다.

• withContext()는 프로세스에 잡을 포함시키지 않고도 다른 컨텍스트로 전환할 수 있게 해주는 일시 중단 함수다.