Posts

Join in Kotlin coroutines

  In Kotlin coroutines, the  join()  function is used to wait for the completion of multiple coroutines running concurrently. It allows you to ensure that all the launched coroutines finish their execution before proceeding further in the code. When you launch multiple coroutines using  launch ,  async , or other coroutine builders, you obtain references to these launched coroutines. You can store these references in variables and later use  join()  on each of these variables to wait for the corresponding coroutines to complete. import kotlinx.coroutines.* suspend fun doTaskA() { println(“Task A started”) delay(2000) // Simulate some asynchronous work for 2 seconds println(“Task A finished”) } suspend fun doTaskB() { println(“Task B started”) delay(3000) // Simulate some asynchronous work for 3 seconds println(“Task B finished”) } fun main() = runBlocking { val jobA = launch { doTaskA() } val jobB = launch { doTaskB() } println(“Launched both coroutines, now waiting for them to complet
Read more

Channels in Kotlin Coroutines

  Channels Channels in Kotlin Coroutines provide a way to transfer a stream of values between coroutines. They are similar to BlockingQueue, but with some key differences. For example, instead of putting an element to a queue, a sender sends it to a channel. Instead of taking an element from a queue, a receiver receives it from a channel. Here’s a simple example: import kotlinx.coroutines.* import kotlinx.coroutines.channels.* fun main () = runBlocking { val channel = Channel< Int >() launch { for (x in 1. .5 ) channel.send(x * x) channel.close() } repeat( 5 ) { println(channel.receive()) } println( "Done!" ) } In this code, we’re creating a channel of Integers. Inside a coroutine, we’re sending squares of numbers from 1 to 5 to the channel, and then closing it. Outside the coroutine, we’re receiving the values from the channel and printing them.
Read more

Suspend Functions of Kotlin Coroutines

  Suspending Functions Suspending functions are a cornerstone of Kotlin Coroutines. They are the functions that can be paused and resumed at a later time. To define a suspending function, you use the  suspend  modifier. Here's a simple example: import kotlinx.coroutines.* suspend fun doSomething () { delay( 1000L ) println( "Doing something" ) } fun main () = runBlocking { launch { doSomething() } } In this code,  doSomething  is a suspending function. Inside  doSomething , we're delaying for one second and then printing a message. We're calling  doSomething  from a coroutine, because suspending functions can only be called from another suspending function or a coroutine.
Read more

Kotlin Coroutines

  Coroutines are lightweight threads. By lightweight,   it means that creating coroutines doesn’t allocate new threads. Instead, they use predefined thread pools and smart scheduling for the purpose of which task to execute next and which tasks later . Coroutines are basically of two types: Stackless Stackful Stackless coroutines,  it means that the coroutines don’t have their own stack, so they don’t map on the native thread. Kotlin Coroutines Features. Lightweight- One can run many coroutines on a single thread due to support for suspension, which doesn’t block the thread where the coroutine is running. Suspending frees memory over blocking while supporting multiple concurrent operations. Built-in cancellation support : Cancellation is generated automatically through the running coroutine hierarchy. Fewer memory leaks : It uses structured concurrency to run operations within a scope. Jetpack integration : Many Jetpack libraries include extensions that provide full coroutines support.
Read more