200819 NAVER TECH CONCERT 03_화려한 코루틴이 내 앱을 감싸네! 코루틴으로 작성해보는 깔끔한 비동기 코드

Android 11 AsyncTask deprecated
“Kotlin Coroutines”

Direct Style
fun loadItem(params: Params) {
val token = requestToken()
val item = requestItem(token, params)
showItem(item)
}

Direct Style
showItem(item)
}
Continuation

onDraw() onDraw() onDraw()
Direct Style
showItem(item)
}
UI Thread

Continuation-Passing Style (CPS)
requestToken { token ->
showItem(item)
}
}

showItem(item)
}
}
Continuation
Callback!

requestItem(token, params) { item ->
showItem(item)
}
}
}

Coroutines Direct Style
suspend fun loadItem(params: Params) {
showItem(item)
}

Coroutines Direct Style
showItem(item)
}
onDraw() onDraw()
UI Thread
suspend resume

코루틴은내부적으로어떻게동작할까?

CPS Transformation
suspend fun requestItem(token: Token, params: Params): Item { ... }
// Decompile bytecode in Java
Object requestItem(
Token token,
Params params,
Continuation<Item> cont
) { ... }

CPS Transformation
interface Continuation<in T> {
val context: CoroutineContext
fun resumeWith(result: Result<T>)
}

CPS Transformation
showItem(item)
}

CPS Transformation
showItem(item)
}
Initial
Continuation

CPS Transformation
showItem(item)
}
Continuation

Callback ???
requestItem(token, params) { item ->
showItem(item)
}
}
}

CPS Transformation
// LABEL 0
// LABEL 1
// LABEL 2
showItem(item)
}

CPS Transformation
val sm = object : ContinuationImpl { ... }
when (sm.label) {
0 -> val token = requestToken()
1 -> val item = requestItem(token, params)
2 -> showItem(item)
}
}

CPS Transformation
when (sm.label) {
0 -> val token = requestToken()
1 -> val item = requestItem(token, params)
2 -> showItem(item)
}
}
State Machine

CPS Transformation
fun loadItem(params: Params, cont: Continuation) {
when (sm.label) {
0 -> requestToken(sm)
1 -> requestItem(token, params, sm)
2 -> showItem(item)
}
}

CPS Transformation
when (sm.label) {
0 -> {
sm.params = params
sm.label = 1
requestToken(sm)
}
2 -> showItem(item)
}
}

CPS Transformation
when (sm.label) {
0 -> {
sm.params = params
sm.label = 1
requestToken(sm)
}
2 -> showItem(item)
}
}
State Machine
Continuation

CPS Transformation
val sm = cont as? ThisSM ?: object : ThisSM {
fun resumeWith(...) {
loadItem(null, this) {
}
}
...
}

CPS Transformation
val sm = ...
when (sm.label) {
0 -> { ... }
1 -> {
val params = sm.params
val token = sm.result as Token
sm.label = 2
requestItem(token, params, sm)
}
2 -> { ... }
}
}

State Machine vs. Callback
•State Machine 은 상태를 저장한 하나의 객체를 공유하지만, Callback 은 매번 closure를 생성해야 함

•복잡한 구조에 대응하기 쉬움
suspend fun loadItems(params: List<Params>) {
for (p in params) {
val item = requestItem(token, p)
showItem(item)
}
}

그래서코루틴을왜쓰는거지?

Why Coroutines ?
• Structured concurrency
➡ 구조화된 동시성 처리로 memory leak 방지

Structured Concurrency
@CheckReturnValue
@BackpressureSupport(BackpressureKind.UNBOUNDED_IN)
@SchedulerSupport(SchedulerSupport.NONE)
public final Disposable subscribe(Consumer<? super T> onNext) {
return subscribe(onNext, Functions.ON_ERROR_MISSING,
Functions.EMPTY_ACTION,
FlowableInternalHelper.RequestMax.INSTANCE);
}

Structured Concurrency
fun CoroutineScope.launch(
context: CoroutineContext = EmptyCoroutineContext,
start: CoroutineStart = CoroutineStart.DEFAULT,
block: suspend CoroutineScope.() -> Unit
): Job { ... }
• RxJava leak warn
• CoroutineScope leak

Why Coroutines ?
• Light weight
➡ 싱글 스레드에서 여러 코루틴을 동시에 실행할 수 있음 (동시성)

Kotlin Flow: Reactive scrabble benchmarks
•Java 8 Stream - RxJava 간 성능 비교를 위해 José Paumard 에 의해 개발됨

•Rx 관련 코드는 David Karnok 가 작성
https://github.com/Kotlin/kotlinx.coroutines/tree/master/benchmarks/src/jmh/kotlin/benchmarks/flow/scrabble

Why Coroutines ?
• Light weight
➡ 싱글 스레드에서 여러 코루틴을 동시에 실행할 수 있음 (동시성)
• Built-in cancellation
➡ 계층 구조를 따라 취소가 자동으로 전파됨
• Simplify asynchronous code
➡ 비동기 코드를 콜백 대신 순차적(sequential)인 코드로 작성할 수 있음
➡ 다양한 Jetpack 라이브러리에서 extensions 등의 형태로 코루틴을 지원

내앱에코루틴을적용해보자!

, CoroutineScope
interface CoroutineScope {
val coroutineContext: CoroutineContext
}
•새로운 코루틴을 시작하는 코루틴 빌더는 모두 CoroutineScope 의 extensions function 으로 구성

, launch() & async()
fun CoroutineScope.launch(
block: suspend CoroutineScope.() -> Unit
): Job { ... }
fun <T> CoroutineScope.async(
block: suspend CoroutineScope.() -> T
): Deferred<T> { ... }

launch() vs. async()
•
• CoroutineScope
• suspend function
Exception .await() Exception X
launch() async()

launch()
val job = launch {
delay(1000)
doSomething()
}

async()
private suspend fun mergeApi(): List<Item> = coroutineScope {
val deferredOne = async { fetchApiOne() }
val deferredTwo = async { fetchApiTwo() }
return deferredOne.await() + deferredTwo.await()
}

}
async()
fetchApiOne() ,
fetchApiTwo()

async()
}
suspend

GlobalScope
object GlobalScope : CoroutineScope {
override val coroutineContext: CoroutineContext
get() = EmptyCoroutineContext
}
•앱 전체 생명주기로 동작하는 top-level CoroutineScope

•대부분의 경우에 사용하면 안됨

GlobalScope
fun ReceiveChannel<Int>.sqrt(): ReceiveChannel<Double> =
GlobalScope.produce(Dispatchers.Unconfined) {
for (number in this) {
send(Math.sqrt(number))
}
}

Kotlin Property Delegates for ViewModels
class AwesomeFragment : Fragment() {
private val model: AwesomeViewModel by viewModels()
}

private fun showChildFragment() = childFragmentManager.commit {
replace(R.id.fragment_child, ChildFragment())
}
}
class ChildFragment : Fragment() { ... }

private fun showChildFragment() = childFragmentManager.commit {
replace(R.id.fragment_child, ChildFragment())
}
}
class ChildFragment : Fragment() {
private val model: AwesomeViewModel by viewModels({ requireParentFragment() })
}

class AwesomeActivity : AppCompatActivity() {
private val sharedModel: SharedViewModel by viewModels()
}
private val sharedModel: SharedViewModel by activityViewModels()
}
class ChildFragment : Fragment() {
private val sharedModel: SharedViewModel by activityViewModels()
}

CoroutineScope ViewModel
class AwesomeViewModel : ViewModel(), CoroutineScope {
}

Context
}

CoroutineContext
• Job
➡ Lifecycle
• CoroutineDispatcher
➡ Threading
• CoroutineExceptionHandler
• CoroutineName

CoroutineContext’s Default
• Job
➡ No parent job
• CoroutineDispatcher
➡ Dispatchers.Default
• CoroutineExceptionHandler
➡ None
• CoroutineName
➡ “coroutine”
context

CoroutineContext
public interface CoroutineContext {
public operator fun <E : Element> get(key: Key<E>): E?
public fun <R> fold(initial: R, operation: (R, Element) -> R): R
public operator fun plus(context: CoroutineContext): CoroutineContext = ...
public fun minusKey(key: Key<*>): CoroutineContext
public interface Key<E : Element>
public interface Element : CoroutineContext { ... }
}

CoroutineContext
}
coroutineContext[Job]

CoroutineContext
}
Job() + Dispathchers.IO

Job
• (Lifecycle)
wait children
+-----+ start +--------+ complete +-------------+ finish +-----------+
| New | -----> | Active | ---------> | Completing | -------> | Completed |
+-----+ +--------+ +-------------+ +-----------+
| cancel / fail |
| +----------------+
| |
V V
+------------+ finish +-----------+
| Cancelling | --------------------------------> | Cancelled |
+------------+ +-----------+

Job
• (Hierarchy)
Parent Job
Child Job Child Job Child Job Child Job

Job
private val job = Job()
get() = job
override fun onCleared() {
super.onCleared()
job.cancel()
}
}
•When a child fails, it propagates cancellation to other children

•When a failure is notified, the scope propagates the exception up

SupervisorJob
private val job = SupervisorJob()
get() = job
super.onCleared()
job.cancel()
}
}
•The failure of a child doesn't affect other children

•When a failure is notified, the scope doesn't do anything

Cooperative cancellation
repeat (5) {
someBlockingTask()
}
repeat (5) {
yield() // or ensureActive()
someBlockingTask()
}

Cooperative cancellation
while (true) {
someBlockingTask()
}
while (isActive) {
someBlockingTask()
}

Dispatchers
actual object Dispatchers {
@JvmStatic
actual val Default: CoroutineDispatcher = createDefaultDispatcher()
@JvmStatic
actual val Main: MainCoroutineDispatcher get() = MainDispatcherLoader.dispatcher
@JvmStatic
actual val Unconfined: CoroutineDispatcher = kotlinx.coroutines.Unconfined
@JvmStatic
val IO: CoroutineDispatcher = DefaultScheduler.IO
}

Main-safe suspend function
suspend fun mainSafeFunc() {
val result = withContext(Dispatchers.IO) {
fetchApi()
}
return result.name
}
• Main(UI) Thread suspend function withContext
➡ e.g. Retrofit 2.6.0+ suspend function

Job + Dispatchers
get() = job + Dispatchers.Main
super.onCleared()
job.cancel()
}
}

get() = job + Dispatchers.Main
init {
launch {
// Call suspend func.
}
}
super.onCleared()
job.cancel()
}
}

Lifecycle-aware coroutine scopes
•For ViewModelScope, use androidx.lifecycle:lifecycle-viewmodel-ktx:2.1.0-beta01 or higher.
class PlainViewModel : ViewModel() {
init {
viewModelScope.launch {
}
}
}

Lifecycle-aware coroutine scopes
•For LifecycleScope, use androidx.lifecycle:lifecycle-runtime-ktx:2.2.0-alpha01 or higher.
// Activity or Fragment
class PlainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
lifecycleScope.launch {
}
lifecycleScope.launchWhenResumed {
}
}
}

ViewModel + LiveData
private val _result = MutableLiveData<String>()
val result: LiveData<String> = _result
init {
viewModelScope.launch {
val computationResult = doComputation()
_result.value = computationResult
}
}
}

LiveData Builder
•For liveData, use androidx.lifecycle:lifecycle-livedata-ktx:2.2.0-alpha01 or higher.
val result: LiveData {
emit(doComputation())
}
}

LiveData Builder
// itemId item
private val itemId = MutableLiveData<String>()
val result = itemId.switchMap {
liveData { emit(fetchItem(it)) }
}
// LiveData
val weather = liveData(Dispatchers.IO) {
emit(LOADING_STRING)
emitSource(dataSource.fetchWeather()) // LiveData
}
}

StateFlow
• LiveData State holder !
• state StateFlow
interface StateFlow<T> : Flow<T> {
val value: T
// always available, reading it never fails
}
interface MutableStateFlow<T> : StateFlow<T> {
override var value: T
// can read & write value
}
fun <T> MutableStateFlow(value: T): MutableStateFlow<T>
// constructor fun

SharedFlow
https://github.com/Kotlin/kotlinx.coroutines/pull/2069

Paging 2
class AwesomeDataSource(parent: Job? = null) : PositionalDataSource<Awesome>(), CoroutineScope {
private val job = SupervisorJob(parent)
get() = Dispatchers.Unconfined + job
override fun loadInitial(params: LoadInitialParams, callback: LoadInitialCallback<Awesome>) {
launch {
runCatching { loadInternal(params.requestedStartPosition, params.requestedLoadSize) }
.fold(
onSuccess = { callback.onResult(it, params.requestedStartPosition) },
onFailure = { callback.onResult(emptyList(), params.requestedStartPosition) }
)
}
}
...
}

Paging 3
•First-class support for Kotlin coroutines and Flow, as well as LiveData and RxJava.

•현재 알파 버전 (3.0.0-alpha04)

Paging 3
@ExperimentalPagingApi
abstract class RemoteMediator<Key : Any, Value : Any> {
abstract suspend fun load(loadType: LoadType, state: PagingState<Key, Value>): MediatorResult
...
}

RxJava - Coroutines
https://github.com/Kotlin/kotlinx.coroutines/tree/master/reactive/kotlinx-coroutines-rx2

RxJava - Coroutines
// Coroutines -> Rx
val single = rxSingle {
// call suspend func.
}
// Rx -> Coroutines
val result = single.await()

Coroutines
suspend fun request(id: String): Awesome = suspendCancellableCoroutine { cont ->
cont.invokeOnCancellation {
// Cancel execution.
}
awesomeModelProvider
.request(id)
.execute(object : Response {
override fun onSuccess(items: Awesome) {
cont.resume(items)
}
override fun onError(message: String?) {
cont.resumeWithException(IOException(message))
}
})
}
launch {
textView.text = request(id).name
}

200819 NAVER TECH CONCERT 03_화려한 코루틴이 내 앱을 감싸네! 코루틴으로 작성해보는 깔끔한 비동기 코드

200819 NAVER TECH CONCERT 03_화려한 코루틴이 내 앱을 감싸네! 코루틴으로 작성해보는 깔끔한 비동기 코드

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to 200819 NAVER TECH CONCERT 03_화려한 코루틴이 내 앱을 감싸네! 코루틴으로 작성해보는 깔끔한 비동기 코드

Similar to 200819 NAVER TECH CONCERT 03_화려한 코루틴이 내 앱을 감싸네! 코루틴으로 작성해보는 깔끔한 비동기 코드 (20)

More from NAVER Engineering

More from NAVER Engineering (20)

Recently uploaded

Recently uploaded (20)

200819 NAVER TECH CONCERT 03_화려한 코루틴이 내 앱을 감싸네! 코루틴으로 작성해보는 깔끔한 비동기 코드