Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Fresh Async with Kotlin

Fresh Async with Kotlin

Introduction to Kotlin Coroutines for a stable released version with Kotlin 1.3. It covers various async programming styles -- callbacks, futures/promises, and Kotlin suspending functions that are easiest to use of all. It shows integration of Kotlin coroutines with a zoo of futures on JVM, compares them with async/await from other languages, introduces structured concurrency and gives a glimpse of CSP. Presented at GOTO Copenhagen 2018.

Roman Elizarov

November 20, 2018
Tweet

More Decks by Roman Elizarov

Other Decks in Programming

Transcript

  1. Speaker: Roman Elizarov • Professional developer since 2000 • Previously

    developed high-perf trading software @ Devexperts • Teach concurrent & distributed programming @ St. Petersburg ITMO University • Chief judge @ Northern Eurasia Contest / ACM ICPC • Now team lead in Kotlin Libraries @ JetBrains
  2. History Simula’67 Coroutines CLU’75 Icon’77 Generators C’72 C++’85 Java’95 C#’00

    Kotlin’11 C#’12 async/await Kotlin 1.1 (‘17) Coroutines Exp. C++20? Java XX? Threads Asynchronous Programming Microservices Kotlin 1.3 (‘18) Coroutines Release Erlang’86 Go’09
  3. Callbacks: before fun requestToken(): Token { // makes request for

    a token & waits return token // returns result when received } 1
  4. Callbacks: after fun requestTokenAsync(cb: (Token) -> Unit) { // makes

    request for a token, invokes callback when done // returns immediately } 1 callback
  5. Callbacks: before fun requestTokenAsync(cb: (Token) -> Unit) { … }

    fun createPost(token: Token, item: Item): Post { // sends item to the server & waits return post // returns resulting post } 2
  6. Callbacks: after fun requestTokenAsync(cb: (Token) -> Unit) { … }

    fun createPostAsync(token: Token, item: Item, cb: (Post) -> Unit) { // sends item to the server, invokes callback when done // returns immediately } 2 callback
  7. Callbacks: before fun requestTokenAsync(cb: (Token) -> Unit) { … }

    fun createPostAsync(token: Token, item: Item, cb: (Post) -> Unit) { … } fun processPost(post: Post) { … } fun postItem(item: Item) { val token = requestToken() val post = createPost(token, item) processPost(post) }
  8. Callbacks: after fun requestTokenAsync(cb: (Token) -> Unit) { … }

    fun createPostAsync(token: Token, item: Item, cb: (Post) -> Unit) { … } fun processPost(post: Post) { … } fun postItem(item: Item) { requestTokenAsync { token -> createPostAsync(token, item) { post -> processPost(post) } } } aka “callback hell” This is simplified. Handling exceptions makes it a real mess
  9. Futures: before fun requestTokenAsync(cb: (Token) -> Unit) { // makes

    request for a token, invokes callback when done // returns immediately } 1
  10. Futures: after fun requestTokenAsync(): Promise<Token> { // makes request for

    a token // returns promise for a future result immediately } 1 future
  11. Futures: before fun requestTokenAsync(): Promise<Token> { … } fun createPostAsync(token:

    Token, item: Item, cb: (Post) -> Unit) { // sends item to the server, invokes callback when done // returns immediately } 2
  12. Futures: after fun requestTokenAsync(): Promise<Token> { … } fun createPostAsync(token:

    Token, item: Item): Promise<Post> { // sends item to the server // returns promise for a future result immediately } future 2
  13. Futures: before fun requestTokenAsync(): Promise<Token> { … } fun createPostAsync(token:

    Token, item: Item): Promise<Post> … fun processPost(post: Post) { … } fun postItem(item: Item) { requestTokenAsync { token -> createPostAsync(token, item) { post -> processPost(post) } } }
  14. Futures: after fun requestTokenAsync(): Promise<Token> { … } fun createPostAsync(token:

    Token, item: Item): Promise<Post> … fun processPost(post: Post) { … } fun postItem(item: Item) { requestTokenAsync() .thenCompose { token -> createPostAsync(token, item) } .thenAccept { post -> processPost(post) } }
  15. Futures: after fun requestTokenAsync(): Promise<Token> { … } fun createPostAsync(token:

    Token, item: Item): Promise<Post> … fun processPost(post: Post) { … } fun postItem(item: Item) { requestTokenAsync() .thenCompose { token -> createPostAsync(token, item) } .thenAccept { post -> processPost(post) } } Callbacks are still here
  16. Futures: after fun requestTokenAsync(): Promise<Token> { … } fun createPostAsync(token:

    Token, item: Item): Promise<Post> … fun processPost(post: Post) { … } fun postItem(item: Item) { requestTokenAsync() .thenCompose { token -> createPostAsync(token, item) } .thenAccept { post -> processPost(post) } } Composable & propagates exceptions No nesting indentation Callbacks are still here
  17. Futures: after fun requestTokenAsync(): Promise<Token> { … } fun createPostAsync(token:

    Token, item: Item): Promise<Post> … fun processPost(post: Post) { … } fun postItem(item: Item) { requestTokenAsync() .thenCompose { token -> createPostAsync(token, item) } .thenAccept { post -> processPost(post) } } But all those operators…
  18. Coroutines: before fun requestTokenAsync(): Promise<Token> { // makes request for

    a token // returns promise for a future result immediately } 1
  19. Coroutines: after suspend fun requestToken(): Token { // makes request

    for a token & suspends return token // returns result when received } 1 natural signature
  20. Coroutines: before suspend fun requestToken(): Token { … } fun

    createPostAsync(token: Token, item: Item): Promise<Post> { // sends item to the server // returns promise for a future result immediately } 2
  21. Coroutines: after suspend fun requestToken(): Token { … } suspend

    fun createPost(token: Token, item: Item): Post { // sends item to the server & suspends return post // returns result when received } 2 natural signature
  22. Coroutines: before suspend fun requestToken(): Token { … } suspend

    fun createPost(token: Token, item: Item): Post { … } fun processPost(post: Post) { … } fun postItem(item: Item) { requestTokenAsync() .thenCompose { token -> createPostAsync(token, item) } .thenAccept { post -> processPost(post) } }
  23. Coroutines: after suspend fun requestToken(): Token { … } suspend

    fun createPost(token: Token, item: Item): Post { … } fun processPost(post: Post) { … } suspend fun postItem(item: Item) { val token = requestToken() val post = createPost(token, item) processPost(post) }
  24. Coroutines: after suspend fun requestToken(): Token { … } suspend

    fun createPost(token: Token, item: Item): Post { … } fun processPost(post: Post) { … } suspend fun postItem(item: Item) { val token = requestToken() val post = createPost(token, item) processPost(post) } Like regular code
  25. Coroutines: after suspend fun requestToken(): Token { … } suspend

    fun createPost(token: Token, item: Item): Post { … } fun processPost(post: Post) { … } suspend fun postItem(item: Item) { val token = requestToken() val post = createPost(token, item) processPost(post) } suspension points
  26. • Custom higher-order functions Bonus features val post = retryIO

    { createPost(token, item) } Everything like in regular code
  27. Kotlin suspending functions callback Kotlin Java/JVM suspend fun createPost(token: Token,

    item: Item): Post { … } Object createPost(Token token, Item item, Continuation<Post> cont) { … }
  28. Kotlin suspending functions callback Kotlin Java/JVM Continuation is a generic

    callback interface suspend fun createPost(token: Token, item: Item): Post { … } Object createPost(Token token, Item item, Continuation<Post> cont) { … } interface Continuation<in T> { val context: CoroutineContext fun resumeWith(result: Result<T>) }
  29. Kotlin suspending functions callback Kotlin Java/JVM suspend fun createPost(token: Token,

    item: Item): Post { … } Object createPost(Token token, Item item, Continuation<Post> cont) { … } interface Continuation<in T> { val context: CoroutineContext fun resumeWith(result: Result<T>) }
  30. Kotlin suspending functions callback Kotlin Java/JVM suspend fun createPost(token: Token,

    item: Item): Post { … } Object createPost(Token token, Item item, Continuation<Post> cont) { … } interface Continuation<in T> { val context: CoroutineContext fun resumeWith(result: Result<T>) }
  31. interface Service { fun createPost(token: Token, item: Item): Call<Post> }

    suspend fun createPost(token: Token, item: Item): Post = serviceInstance.createPost(token, item).await() natural signature
  32. interface Service { fun createPost(token: Token, item: Item): Call<Post> }

    suspend fun createPost(token: Token, item: Item): Post = serviceInstance.createPost(token, item).await() Suspending extension function from integration library
  33. Callbacks everywhere suspend fun <T> Call<T>.await(): T { enqueue(object :

    Callback<T> { override fun onResponse(call: Call<T>, response: Response<T>) { // todo } override fun onFailure(call: Call<T>, t: Throwable) { // todo } }) }
  34. suspend fun <T> Call<T>.await(): T = suspendCoroutine { cont ->

    enqueue(object : Callback<T> { override fun onResponse(call: Call<T>, response: Response<T>) { if (response.isSuccessful) cont.resume(response.body()!!) else cont.resumeWithException(ErrorResponse(response)) } override fun onFailure(call: Call<T>, t: Throwable) { cont.resumeWithException(t) } }) }
  35. suspend fun <T> Call<T>.await(): T = suspendCoroutine { cont ->

    enqueue(object : Callback<T> { override fun onResponse(call: Call<T>, response: Response<T>) { if (response.isSuccessful) cont.resume(response.body()!!) else cont.resumeWithException(ErrorResponse(response)) } override fun onFailure(call: Call<T>, t: Throwable) { cont.resumeWithException(t) } }) }
  36. Install callback suspend fun <T> Call<T>.await(): T = suspendCoroutine {

    cont -> enqueue(object : Callback<T> { override fun onResponse(call: Call<T>, response: Response<T>) { if (response.isSuccessful) cont.resume(response.body()!!) else cont.resumeWithException(ErrorResponse(response)) } override fun onFailure(call: Call<T>, t: Throwable) { cont.resumeWithException(t) } }) }
  37. Install callback suspend fun <T> Call<T>.await(): T = suspendCoroutine {

    cont -> enqueue(object : Callback<T> { override fun onResponse(call: Call<T>, response: Response<T>) { if (response.isSuccessful) cont.resume(response.body()!!) else cont.resumeWithException(ErrorResponse(response)) } override fun onFailure(call: Call<T>, t: Throwable) { cont.resumeWithException(t) } }) }
  38. Analyze response suspend fun <T> Call<T>.await(): T = suspendCoroutine {

    cont -> enqueue(object : Callback<T> { override fun onResponse(call: Call<T>, response: Response<T>) { if (response.isSuccessful) cont.resume(response.body()!!) else cont.resumeWithException(ErrorResponse(response)) } override fun onFailure(call: Call<T>, t: Throwable) { cont.resumeWithException(t) } }) }
  39. Analyze response suspend fun <T> Call<T>.await(): T = suspendCoroutine {

    cont -> enqueue(object : Callback<T> { override fun onResponse(call: Call<T>, response: Response<T>) { if (response.isSuccessful) cont.resume(response.body()!!) else cont.resumeWithException(ErrorResponse(response)) } override fun onFailure(call: Call<T>, t: Throwable) { cont.resumeWithException(t) } }) } That’s all
  40. Coroutines revisited suspend fun requestToken(): Token { … } suspend

    fun createPost(token: Token, item: Item): Post { … } fun processPost(post: Post) { … } suspend fun postItem(item: Item) { val token = requestToken() val post = createPost(token, item) processPost(post) }
  41. Coroutines revisited suspend fun requestToken(): Token { … } suspend

    fun createPost(token: Token, item: Item): Post { … } fun processPost(post: Post) { … } fun postItem(item: Item) { val token = requestToken() val post = createPost(token, item) processPost(post) }
  42. Coroutines revisited suspend fun requestToken(): Token { … } suspend

    fun createPost(token: Token, item: Item): Post { … } fun processPost(post: Post) { … } fun postItem(item: Item) { val token = requestToken() val post = createPost(token, item) processPost(post) } Error: Suspend function 'requestToken' should be called only from a coroutine or another suspend function
  43. Coroutines revisited suspend fun requestToken(): Token { … } suspend

    fun createPost(token: Token, item: Item): Post { … } fun processPost(post: Post) { … } fun postItem(item: Item) { val token = requestToken() val post = createPost(token, item) processPost(post) } Can suspend execution
  44. Coroutines revisited suspend fun requestToken(): Token { … } suspend

    fun createPost(token: Token, item: Item): Post { … } fun processPost(post: Post) { … } fun postItem(item: Item) { val token = requestToken() val post = createPost(token, item) processPost(post) } Can suspend execution A regular function cannot
  45. Coroutines revisited suspend fun requestToken(): Token { … } suspend

    fun createPost(token: Token, item: Item): Post { … } fun processPost(post: Post) { … } fun postItem(item: Item) { val token = requestToken() val post = createPost(token, item) processPost(post) } Can suspend execution A regular function cannot One cannot simply invoke a suspending function
  46. Launch fun postItem(item: Item) { GlobalScope.launch { val token =

    requestToken() val post = createPost(token, item) processPost(post) } } coroutine builder
  47. fun postItem(item: Item) { GlobalScope.launch { val token = requestToken()

    val post = createPost(token, item) processPost(post) } } Fire and forget!
  48. fun postItem(item: Item) { GlobalScope.launch { val token = requestToken()

    val post = createPost(token, item) processPost(post) } } Fire and forget! We launch for its side effects
  49. fun postItem(item: Item) { GlobalScope.launch { val token = requestToken()

    val post = createPost(token, item) processPost(post) } } Returns immediately, coroutine works in background thread pool
  50. fun postItem(item: Item) { GlobalScope.launch { val token = requestToken()

    val post = createPost(token, item) processPost(post) } }
  51. fun postItem(item: Item) { GlobalScope.launch(Dispatchers.Main) { val token = requestToken()

    val post = createPost(token, item) processPost(post) } } Dispatcher Just specify the dispatcher
  52. fun postItem(item: Item) { GlobalScope.launch(Dispatchers.Main) { val token = requestToken()

    val post = createPost(token, item) processPost(post) } } Dispatcher And it gets executed on the Main thread
  53. Kotlin-way suspend fun postItem(item: Item) { val token = requestToken()

    val post = createPost(token, item) processPost(post) } Kotlin suspend fun requestToken(): Token { … } suspend fun createPost(token: Token, item: Item): Post { … } fun processPost(post: Post) { … }
  54. async Task postItem(Item item) { var token = await requestToken();

    var post = await createPost(token, item); processPost(post); } Classic-way C# approach to the same problem (also Python, TS, Dart, coming to JS) C# async Task<Token> requestToken() { … } async Task<Post> createPost(Token token, Item item) { … } void processPost(Post post) { … }
  55. async Task postItem(Item item) { var token = await requestToken();

    var post = await createPost(token, item); processPost(post); } Classic-way mark with async C# async Task<Token> requestToken() { … } async Task<Post> createPost(Token token, Item item) { … } void processPost(Post post) { … }
  56. async Task postItem(Item item) { var token = await requestToken();

    var post = await createPost(token, item); processPost(post); } Classic-way use await to suspend C# async Task<Token> requestToken() { … } async Task<Post> createPost(Token token, Item item) { … } void processPost(Post post) { … }
  57. async Task postItem(Item item) { var token = await requestToken();

    var post = await createPost(token, item); processPost(post); } Classic-way C# returns a future async Task<Token> requestToken() { … } async Task<Post> createPost(Token token, Item item) { … } void processPost(Post post) { … }
  58. Why no await keyword in Kotlin? The problem with async

    requestToken() VALID –> produces Task<Token> await requestToken() VALID –> produces Token concurrent behavior sequential behavior C# C# default
  59. Kotlin suspending functions are designed to imitate sequential behavior by

    default Concurrency is hard Concurrency has to be explicit
  60. Use-case for async var promise1 = loadImageAsync(name1); var promise2 =

    loadImageAsync(name2); async Task<Image> loadImageAsync(String name) { … } Start multiple operations concurrently C#
  61. Use-case for async var promise1 = loadImageAsync(name1); var promise2 =

    loadImageAsync(name2); var image1 = await promise1; var image2 = await promise2; async Task<Image> loadImageAsync(String name) { … } and then wait for them C#
  62. Use-case for async var result = combineImages(image1, image2); C# var

    promise1 = loadImageAsync(name1); var promise2 = loadImageAsync(name2); var image1 = await promise1; var image2 = await promise2; async Task<Image> loadImageAsync(String name) { … }
  63. fun loadImageAsync(name: String): Deferred<Image> = GlobalScope.async { … } val

    deferred1 = loadImageAsync(name1) val deferred2 = loadImageAsync(name2) Start multiple operations concurrently Kotlin
  64. fun loadImageAsync(name: String): Deferred<Image> = GlobalScope.async { … } val

    deferred1 = loadImageAsync(name1) val deferred2 = loadImageAsync(name2) val image1 = deferred1.await() val image2 = deferred2.await() and then wait for them await function Suspends until deferred is complete Kotlin
  65. fun loadImageAsync(name: String): Deferred<Image> = GlobalScope.async { … } val

    deferred1 = loadImageAsync(name1) val deferred2 = loadImageAsync(name2) val image1 = deferred1.await() val image2 = deferred2.await() val result = combineImages(image1, image2) Kotlin But what if this crashes? Crash?
  66. fun loadImageAsync(name: String): Deferred<Image> = GlobalScope.async { … } val

    deferred1 = loadImageAsync(name1) val deferred2 = loadImageAsync(name2) val image1 = deferred1.await() val image2 = deferred2.await() val result = combineImages(image1, image2) Kotlin Crash? This one leaks But what if this crashes?
  67. Idiomatic: Using async function when needed suspend fun loadImage(name: String):

    Image { … } Is defined as suspending function, not async
  68. Idiomatic: Using async function when needed suspend fun loadImage(name: String):

    Image { … } suspend fun loadAndCombine(name1: String, name2: String): Image = coroutineScope { val deferred1 = async { loadImage(name1) } val deferred2 = async { loadImage(name2) } combineImages(deferred1.await(), deferred2.await()) } Structured concurrency
  69. Idiomatic: Using async function when needed suspend fun loadImage(name: String):

    Image { … } suspend fun loadAndCombine(name1: String, name2: String): Image = coroutineScope { val deferred1 = async { loadImage(name1) } val deferred2 = async { loadImage(name2) } combineImages(deferred1.await(), deferred2.await()) }
  70. Idiomatic: Using async function when needed suspend fun loadImage(name: String):

    Image { … } suspend fun loadAndCombine(name1: String, name2: String): Image = coroutineScope { val deferred1 = async { loadImage(name1) } val deferred2 = async { loadImage(name2) } combineImages(deferred1.await(), deferred2.await()) }
  71. Idiomatic: Using async function when needed suspend fun loadImage(name: String):

    Image { … } suspend fun loadAndCombine(name1: String, name2: String): Image = coroutineScope { val deferred1 = async { loadImage(name1) } val deferred2 = async { loadImage(name2) } combineImages(deferred1.await(), deferred2.await()) }
  72. Kotlin approach to async requestToken() VALID –> produces Token async

    { requestToken() } VALID –> produces Deferred<Token> sequential behavior concurrent behavior Kotlin Kotlin default
  73. Structured concurrency suspend fun loadImage(name: String): Image { … }

    suspend fun loadAndCombine(name1: String, name2: String): Image = coroutineScope { val deferred1 = async { loadImage(name1) } val deferred2 = async { loadImage(name2) } combineImages(deferred1.await(), deferred2.await()) }
  74. Crash suspend fun loadImage(name: String): Image { … } suspend

    fun loadAndCombine(name1: String, name2: String): Image = coroutineScope { val deferred1 = async { loadImage(name1) } val deferred2 = async { loadImage(name2) } combineImages(deferred1.await(), deferred2.await()) } Crashes?
  75. Cancels scope suspend fun loadImage(name: String): Image { … }

    suspend fun loadAndCombine(name1: String, name2: String): Image = coroutineScope { val deferred1 = async { loadImage(name1) } val deferred2 = async { loadImage(name2) } combineImages(deferred1.await(), deferred2.await()) } Cancels
  76. Cancels children suspend fun loadImage(name: String): Image { … }

    suspend fun loadAndCombine(name1: String, name2: String): Image = coroutineScope { val deferred1 = async { loadImage(name1) } val deferred2 = async { loadImage(name2) } combineImages(deferred1.await(), deferred2.await()) } Cancels
  77. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } }
  78. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } println(fibonacci.take(10).toList())
  79. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } println(fibonacci.take(10).toList()) >> [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
  80. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } A coroutine builder with restricted suspension
  81. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } A suspending function in the scope of buildSequence
  82. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } println(fibonacci.take(10).toList()) Synchronous
  83. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } val iter = fibonacci.iterator()
  84. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } val iter = fibonacci.iterator() println(iter.next())
  85. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } val iter = fibonacci.iterator() println(iter.next())
  86. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } val iter = fibonacci.iterator() println(iter.next())
  87. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } val iter = fibonacci.iterator() println(iter.next())
  88. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } val iter = fibonacci.iterator() println(iter.next()) // 1
  89. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } val iter = fibonacci.iterator() println(iter.next()) // 1 println(iter.next())
  90. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } val iter = fibonacci.iterator() println(iter.next()) // 1 println(iter.next())
  91. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } val iter = fibonacci.iterator() println(iter.next()) // 1 println(iter.next())
  92. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } val iter = fibonacci.iterator() println(iter.next()) // 1 println(iter.next())
  93. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } val iter = fibonacci.iterator() println(iter.next()) // 1 println(iter.next())
  94. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } val iter = fibonacci.iterator() println(iter.next()) // 1 println(iter.next()) // 1
  95. Fibonacci sequence val fibonacci = sequence { var cur =

    1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } val iter = fibonacci.iterator() println(iter.next()) // 1 println(iter.next()) // 1 etc ad infinum
  96. Concurrent Fibonacci sequence val fibonacci = GlobalScope.produce { var cur

    = 1 var next = 1 while (true) { send(cur) val tmp = cur + next cur = next next = tmp } } Asynchronous (can be in different thread)
  97. Concurrent Fibonacci sequence val fibonacci = GlobalScope.produce { var cur

    = 1 var next = 1 while (true) { send(cur) val tmp = cur + next cur = next next = tmp } } fun main(args: Array<String>) = runBlocking { println(fibonacci.receive()) } Another coroutine Asynchronous (can be in different thread)
  98. Concurrent Fibonacci sequence val fibonacci = GlobalScope.produce { var cur

    = 1 var next = 1 while (true) { send(cur) val tmp = cur + next cur = next next = tmp } } fun main(args: Array<String>) = runBlocking { println(fibonacci.receive()) } Another coroutine Receives from channel Asynchronous (can be in different thread)
  99. Concurrent Fibonacci sequence val fibonacci = GlobalScope.produce { var cur

    = 1 var next = 1 while (true) { send(cur) val tmp = cur + next cur = next next = tmp } } fun main(args: Array<String>) = runBlocking { println(fibonacci.receive()) // 1 }
  100. Concurrent Fibonacci sequence val fibonacci = GlobalScope.produce { var cur

    = 1 var next = 1 while (true) { send(cur) val tmp = cur + next cur = next next = tmp } } fun main(args: Array<String>) = runBlocking { println(fibonacci.receive()) // 1 println(fibonacci.receive()) // 1 } etc ad infinum