Vignesh Prabhu

Vignesh Prabhu

Coroutines Basics

Coroutines Basics

What is coroutines ?

  • is used to do suspendable computation
  • is a light weight thread
  • runs a block of code concurrently with rest of code

A coroutine is not bound to one thread which means it can suspend in one thread and resumes its execution in another thread.

Basic blocks

runBlocking

  • is a coroutine builder which bridges the regular code with the code within runBlocking {...} block

launch{...}

  • is a coroutine builder
  • launches a new coroutine which concurrently runs with the rest of code .

delay

  • suspending function
  • it suspends a coroutine for a specific amount of time eg: delay(2000L)

Code

fun main() = runBlocking {
    launch {
        delay(2000L)
        println("I am fine!")
    }
    println("How are you ?")
}

Suspend

  • suspend function can be use inside coroutines like regular functions but they can only call other suspending function.

Code

fun main() = runBlocking {
    launch {
       doReply()
    }
    println("How are you ?")
}

suspend fun doReply(){
    delay(2000L)
    println("I am fine!")
}

Scope Builder

  • Scope builders are one which is used to run coroutines inside a scope

runBlocking

  • blocks the current thread for waiting until it executes the block of code coroutines

coroutineScope

  • just suspends the block of code , releasing the underlying thread for other usage
  • we can call coroutineScope from any suspend function

Code

fun main() = runBlocking {
    doReply()
    println("Done")
}

suspend fun doReply() = coroutineScope {
    launch {
        delay(1000L)
        println("I am Fine")
    }
    println("How are you? ")
}

Concurrency

coroutineScope builder can be used inside any suspending functions to perform multiple concurrent operations

Code

fun main() = runBlocking {
    doReply()
    println("Done")
}

suspend fun doReply() = coroutineScope {
    /*launch 1*/
    launch {
        delay(1000L)
        println("I am Fine")
    }
    /*launch 2*/
    launch {
        delay(2000L)
        println("I am in native")
    }
    println("How are you? ")
    println("Where are you? ")
}

Code Explanation:

  • Both the launch{...} that is launch1 and launch2 is executed concurrently which means launch1 is executed at 1 second from start and launch 2 is executed at 2 seconds from start
  • launch1 and launch2 is executed concurrently at the same time .

Coroutines are light weight

  • Lets look at the following example
    fun main() =
      runBlocking {
          repeat(100_000) {
              launch {
                  delay(2000L)
                  println("Done!")
              }
          }
      }
    
    The above launches 100k coroutines and after 2 seconds Done! will be printed.

If we try the same with Java , it will throw OutOfMemoryError

 
Share this