Talking about the kotlin's coroutines. How the kotlin compiler implements the keyword "suspend" and introduce some implementation detail in stdlib.

5. ), (

6. • ) 3
• +
•
•
•
3 :
• :
• ( , : #

7. -
- -

9. *
*
*

11. fun requestToken(): Token { ... }
fun createTweet(token: Token, message: String): Tweet { ... }
fun processTweet(tweet: Tweet) { ... }

12. fun requestToken(): Token { ... }
fun createTweet(token: Token, message: String): Tweet { ... }
fun processTweet(tweet: Tweet) { ... }
fun postTweet(message: String) {
val token = requestToken()
val tweet = createTweet(token, message)
processTweet(tweet)
}

13. fun requestTokenAsync(cb: (Token) -> Unit) { ... }
fun createTweetAsync(token: Token, message: String, cb: (Tweet) -> Unit) { ... }
fun processTweetAsync(tweet: Tweet) { ... }

14. fun requestTokenAsync(cb: (Token) -> Unit) { ... }
fun createTweetAsync(token: Token, message: String, cb: (Tweet) -> Unit) { ... }
fun processTweetAsync(tweet: Tweet) { ... }
fun postTweet(message: String) {
requestTokenAsync { token ->
createPostAsync(token, message) { post ->
processPostAsync(post)
}
}
}
Callback Hell!

15. fun requestToken(): Observable<Token> { ... }
fun createTweet(token: Token, message: String): Observable<Tweet> { ... }
fun processTweet(tweet: Tweet) { ... }

16. fun postTweet(message: String) {
requestToken()
.subscribeOn(Schedulers.io())
.flatMap { token -> createTweet(token, message) }
.subscribe { tweet ->
processTweet()
}
}
fun requestToken(): Observable<Token> { ... }
fun createTweet(token: Token, message: String): Observable<Tweet> { ... }
fun processTweet(tweet: Tweet) { ... }
Not intuitive.
Learning curve is high

17. suspend fun requestToken(): Token { ... }
suspend fun createTweet(token: Token, message: String): Tweet { ... }
suspend fun processTweet(tweet: Tweet) { ... }

18. suspend fun requestToken(): Token { ... }
suspend fun createTweet(token: Token, message: String): Tweet { ... }
suspend fun processTweet(tweet: Tweet) { ... }
! ! !!
fun postTweet(message: String) = runBlocking {
launch {
val token = requestToken()
val tweet = createTweet(token, message)
processTweet(tweet)
}
}
Coroutine builder

19. fun main(args: Array<String>) {
val jobs = List(10000) {
thread {
Thread.sleep(1000)
print(“${Thread.currentThread().name}n”)
}
}
jobs.forEach { it.join() }
}

20. fun main(args: Array<String>) {
val jobs = List(10000) {
launch {
delay(1000)
print(“${Thread.currentThread().name}n”)
}
}
jobs.forEach { it.join() }
}
!!

22. ( :
• : : - . suspend
) : .
• ( ) - :
)
• - : stdlib
kotlinx.coroutines
Kotlin’s Coroutines

23. ( :
• : : - . suspend
) : .
• ( ) - :
)
• - :
kotlinx.coroutinesCore
API
kotlin
1.2
Kotlin’s Coroutines

24. suspend fun method(): Int
fun method(block: suspend () -> Int): Int
fun method(block: suspend Int.() -> Int): Int

25. suspend

26. !

27. fun postTweet(message: String) = runBlocking {
launch {
val token = requestToken()
val tweet = createTweet(token, message)
processTweet(tweet)
... //other non-suspending snippets
}
}
1
2
3
4

28. public static final Object method(Continuation<? super Integer> cont)
public static final Integer method(
Function1<? super Continuation<? super Integer>, ? extends Object> block)
public static final Integer method(
Function2<? super Integer, ? super Continuation<? super Integer>, ? extends
Object> block)
* *
Continuation Passing Style (CPS)

29. public interface Continuation<in T> {
public val context: CoroutineContext
public fun resume(value: T)
public fun resumeWithException(exception: Throwable)
}

30. public interface Continuation<in T> {
public val context: CoroutineContext
public fun resume(result: Result<T>)
}
public inline class Result<out T>(internal value: Any?) {
public val isSuccess: Boolean = value !is Failure
public val isFailure: Boolean = value is Failure
}

31. @SinceKotlin("1.1")
public actual val COROUTINE_SUSPENDED: Any get() = CoroutineSuspendedMarker
private object CoroutineSuspendedMarker

32. public static final Object postTweet(Continuation<Unit> cont) {
if(cont instanceof CoroutineImpl$1) {
...
} else {
Continuation contImpl = new CoroutineImpl(cont) {
Object data;
Throwable exception;
public final Object onResume(Object data, Throwable throwable) {
this.data = data;
this.exception = throwable;
this.label |= Integer.MIN_VALUE;
return method(this);
}
};
}
}
Anonymous class

33. Continuation contImpl = ...
data = contImpl.data
exception = contImpl.exception
isSuspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
switch(contImpl.getLabel()) {
case 0: {
contImpl.setLabel(1);
result = requestToken(contImpl);
if (result == isSuspended) {
return isSuspended
}
}
case 1: {
result = (String)data
return result
}
...
case n: {
}
}

34. 1.requestToken 2.createTweet 3.processTweet
postTweet
postTweet resumeSUSPEND SUSPEND resume SUSPEND
4.non-
suspending
resume

35. •
•
•

36. •
•
•
public fun <T> (suspend () -> T).createCoroutine(completion: Continuation<T>): Continuation<Unit> =
SafeContinuation(createCoroutineUnchecked(receiver, completion), COROUTINE_SUSPENDED)

37. •
•
•
public fun <T> (suspend () -> T).startCoroutine(completion: Continuation<T>) {
createCoroutineUnchecked(completion).resume(Unit)
}
public fun <T> (suspend () -> T).createCoroutine(completion: Continuation<T>): Continuation<Unit> =
SafeContinuation(createCoroutineUnchecked(receiver, completion), COROUTINE_SUSPENDED)

38. •
•
•
public fun <T> (suspend () -> T).startCoroutine(completion: Continuation<T>) {
createCoroutineUnchecked(completion).resume(Unit)
}
public fun <T> (suspend () -> T).createCoroutine(completion: Continuation<T>): Continuation<Unit> =
SafeContinuation(createCoroutineUnchecked(receiver, completion), COROUTINE_SUSPENDED)
public suspend inline fun <T> suspendCoroutine(crossinline block: (Continuation<T>) -> Unit): T =
suspendCoroutineOrReturn { c: Continuation<T> ->
val safe = SafeContinuation(c)
block(safe)
safe.getResult()
}

39. public actual fun <T> (suspend () -> T).createCoroutineUnchecked(
completion: Continuation<T>
): Continuation<Unit> =
if (this !is kotlin.coroutines.experimental.jvm.internal.CoroutineImpl)
buildContinuationByInvokeCall(completion) {
(this is Function1<Continuation<T>, Any?>).invoke(completion)
}
else
(this.create(completion) as kotlin.coroutines.experimental.jvm.internal.CoroutineImpl).facade

40. public actual fun <T> (suspend () -> T).createCoroutineUnchecked(
completion: Continuation<T>
): Continuation<Unit> =
if (this !is kotlin.coroutines.experimental.jvm.internal.CoroutineImpl)
buildContinuationByInvokeCall(completion) {
(this is Function1<Continuation<T>, Any?>).invoke(completion)
}
else
(this.create(completion) as kotlin.coroutines.experimental.jvm.internal.CoroutineImpl).facade
private var _facade: Continuation<Any?>? = null
val facade: Continuation<Any?> get() {
if (_facade == null) _facade = interceptContinuationIfNeeded(_context!!, this)
return _facade!!
}

41. @Volatile
private var result: Any? = initialResult
internal actual class SafeContinuation <in T>
internal actual constructor(
class val delegate: Continuation<T>,
initialResult: Any?
) : Continuation<T>
private class Fail(val exception: Throwable)
internal actual fun getResult(): Any? {
var result = this.result
if (result.compareAndSet(this, UNDECIDED, COROUTINE_SUSPENDED) return COROUTINE_SUSPENDED)
result = this.result
when {
result === RESUMED -> return COROUTINE_SUSPENDED
result is Faile -> throw result.exception
else -> else result
}
}

43. . - - -/- .

44. • 0 F 8 9 9 E 69D
FF E 87H F 7 1 D 9 K F 9 0 F
9
• 97 F 6 7 9 8 FF E F 6 7 29 79 F 67
• 796 -- / FF E H 7 6 E 7 7 9D F H9
F F E : D 7
• .F D FF F D

45. • . . . .
• . . . . . . . . .
• . . . . . . . .
• . . . .
•