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

2. NAVER |
!

3. Android 11 AsyncTask deprecated
“Kotlin Coroutines”

4. Kotlin First
Coroutines First

5. 코루틴이뭐지?

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

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

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

9. onDraw() onDraw() onDraw()
Direct Style
fun loadItem(params: Params) {
val token = requestToken()
val item = requestItem(token, params)
showItem(item)
}
UI Thread

10. Continuation-Passing Style (CPS)
fun loadItem(params: Params) {
requestToken { token ->
val item = requestItem(token, params)
showItem(item)
}
}

11. Continuation-Passing Style (CPS)
fun loadItem(params: Params) {
requestToken { token ->
val item = requestItem(token, params)
showItem(item)
}
}

12. Continuation-Passing Style (CPS)
fun loadItem(params: Params) {
requestToken { token ->
val item = requestItem(token, params)
showItem(item)
}
}
Continuation
Callback!

13. Continuation-Passing Style (CPS)
fun loadItem(params: Params) {
requestToken { token ->
requestItem(token, params) { item ->
showItem(item)
}
}
}

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

15. Coroutines Direct Style
suspend fun loadItem(params: Params) {
val token = requestToken()
val item = requestItem(token, params)
showItem(item)
}
onDraw() onDraw()
UI Thread
suspend resume

16. Coroutines Direct Style
suspend fun loadItem(params: Params) {
val token = requestToken()
val item = requestItem(token, params)
showItem(item)
}
onDraw() onDraw()
UI Thread
suspend resume

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

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

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

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

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

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

23. CPS Transformation
suspend fun loadItem(params: Params) {
val token = requestToken()
val item = requestItem(token, params)
showItem(item)
}

24. CPS Transformation
suspend fun loadItem(params: Params) {
val token = requestToken()
val item = requestItem(token, params)
showItem(item)
}
Initial
Continuation

25. CPS Transformation
suspend fun loadItem(params: Params) {
val token = requestToken()
val item = requestItem(token, params)
showItem(item)
}
Continuation

26. CPS Transformation
suspend fun loadItem(params: Params) {
val token = requestToken()
val item = requestItem(token, params)
showItem(item)
}
Continuation

27. Callback ???
fun loadItem(params: Params) {
requestToken { token ->
requestItem(token, params) { item ->
showItem(item)
}
}
}

28. CPS Transformation
suspend fun loadItem(params: Params) {
// LABEL 0
val token = requestToken()
// LABEL 1
val item = requestItem(token, params)
// LABEL 2
showItem(item)
}

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

30. CPS Transformation
suspend fun loadItem(params: Params) {
val sm = object : ContinuationImpl { ... }
when (sm.label) {
0 -> val token = requestToken()
1 -> val item = requestItem(token, params)
2 -> showItem(item)
}
}
State Machine

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

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

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

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

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

36. CPS Transformation
fun loadItem(params: Params, cont: Continuation) {
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 -> { ... }
}
}

37. CPS Transformation
fun loadItem(params: Params, cont: Continuation) {
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 -> { ... }
}
}

38. CPS Transformation
fun loadItem(params: Params, cont: Continuation) {
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 -> { ... }
}
}

39. State Machine vs. Callback
•State Machine 은 상태를 저장한 하나의 객체를 공유하지만, Callback 은 매번 closure를 생성해야 함
•복잡한 구조에 대응하기 쉬움
suspend fun loadItems(params: List<Params>) {
for (p in params) {
val token = requestToken()
val item = requestItem(token, p)
showItem(item)
}
}

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

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

42. 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);
}

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

44. Why Coroutines ?
• Structured concurrency
➡ 구조화된 동시성 처리로 memory leak 방지
• Light weight
➡ 싱글 스레드에서 여러 코루틴을 동시에 실행할 수 있음 (동시성)

45. 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

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

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

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

49. , launch() & async()
fun CoroutineScope.launch(
context: CoroutineContext = EmptyCoroutineContext,
start: CoroutineStart = CoroutineStart.DEFAULT,
block: suspend CoroutineScope.() -> Unit
): Job { ... }
fun <T> CoroutineScope.async(
context: CoroutineContext = EmptyCoroutineContext,
start: CoroutineStart = CoroutineStart.DEFAULT,
block: suspend CoroutineScope.() -> T
): Deferred<T> { ... }

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

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

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

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

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

55. GlobalScope
object GlobalScope : CoroutineScope {
override val coroutineContext: CoroutineContext
get() = EmptyCoroutineContext
}
•앱 전체 생명주기로 동작하는 top-level CoroutineScope
•대부분의 경우에 사용하면 안됨

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

57. ViewModel

58. Jetpack ViewModel

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

60. 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() { ... }

61. 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 val model: AwesomeViewModel by viewModels({ requireParentFragment() })
}

62. 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 val model: AwesomeViewModel by viewModels({ requireParentFragment() })
}

63. Kotlin Property Delegates for ViewModels
class AwesomeActivity : AppCompatActivity() {
private val sharedModel: SharedViewModel by viewModels()
}
class AwesomeFragment : Fragment() {
private val sharedModel: SharedViewModel by activityViewModels()
}
class ChildFragment : Fragment() {
private val sharedModel: SharedViewModel by activityViewModels()
}

64. Kotlin Property Delegates for ViewModels
class AwesomeActivity : AppCompatActivity() {
private val sharedModel: SharedViewModel by viewModels()
}
class AwesomeFragment : Fragment() {
private val sharedModel: SharedViewModel by activityViewModels()
}
class ChildFragment : Fragment() {
private val sharedModel: SharedViewModel by activityViewModels()
}

65. CoroutineScope ViewModel
class AwesomeViewModel : ViewModel(), CoroutineScope {
override val coroutineContext: CoroutineContext
get() = EmptyCoroutineContext
}

66. Context
class AwesomeViewModel : ViewModel(), CoroutineScope {
override val coroutineContext: CoroutineContext
get() = EmptyCoroutineContext
}

67. CoroutineContext

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

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

70. 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 { ... }
}

71. 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 { ... }
}

72. 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 { ... }
}

73. 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 { ... }
}

74. 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 { ... }
}

75. 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 { ... }
}

76. 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 { ... }
}

77. 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[Job]

78. 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 { ... }
}
Job() + Dispathchers.IO

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

80. Job
• (Hierarchy)
Parent Job
Child Job Child Job Child Job Child Job

81. Job
class AwesomeViewModel : ViewModel(), CoroutineScope {
private val job = Job()
override val coroutineContext: CoroutineContext
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

82. SupervisorJob
class AwesomeViewModel : ViewModel(), CoroutineScope {
private val job = SupervisorJob()
override val coroutineContext: CoroutineContext
get() = job
override fun onCleared() {
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

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

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

85. 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
}

86. 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

87. Job + Dispatchers
class AwesomeViewModel : ViewModel(), CoroutineScope {
private val job = SupervisorJob()
override val coroutineContext: CoroutineContext
get() = job + Dispatchers.Main
override fun onCleared() {
super.onCleared()
job.cancel()
}
}

88. class AwesomeViewModel : ViewModel(), CoroutineScope {
private val job = SupervisorJob()
override val coroutineContext: CoroutineContext
get() = job + Dispatchers.Main
init {
launch {
// Call suspend func.
}
}
override fun onCleared() {
super.onCleared()
job.cancel()
}
}

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

90. 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 {
// Call suspend func.
}
lifecycleScope.launchWhenResumed {
// Call suspend func.
}
}
}

91. 코루틴과LiveData

92. ViewModel + LiveData

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

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

95. LiveData Builder
class PlainViewModel : ViewModel() {
// 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
}
}

96. 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

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

98. Paging

99. Paging 2
class AwesomeDataSource(parent: Job? = null) : PositionalDataSource<Awesome>(), CoroutineScope {
private val job = SupervisorJob(parent)
override val coroutineContext: CoroutineContext
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) }
)
}
}
...
}

100. Paging 3
•First-class support for Kotlin coroutines and Flow, as well as LiveData and RxJava.
•현재 알파 버전 (3.0.0-alpha04)

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

102. Single source of truth

103. RxJava-Coroutines상호변환

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

105. RxJava - Coroutines

106. RxJava - Coroutines

107. RxJava - Coroutines

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

109. 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
}