What are Coroutines in Kotlin

Why Do You Need Coroutines?

In the modern world, nobody prefers to wait for anything. Instead, we all want a speedy outcome from everything as quickly as possible, which is often not achievable. Similar to this, an app conducts a variety of tasks, and the operating times for each task vary from one another. As a result, sometimes certain tasks take a very long time, while others continually wait for their turn. 

Client-side and server-side experiences are made fluid through the usage of asynchronous programming. Asynchronous now means that multiple tasks can be done out parallel without requiring other processes to wait for them to finish. Because the callback technique is not required, it is simple to build asynchronous code in coroutines, which also makes it easier and more legible.

Let’s start with Threads, and then we look into Coroutines Kotlin.

About Threads

You must first understand threads to understand Coroutines Kotlin. Every time a program starts, a process with memory, a process id, etc., is created.

There is at least one thread for each process. These threads function sequentially, one after the other, and aid high-performance applications.

The second thread performs the remaining instructions whenever a thread becomes stuck while executing an instruction.

Go ahead and learn about Coroutines Kotlin now.

Coroutines Feature

• Integration of Jetpack: There are several Jetpack libraries that offer support for Coroutines. The Jetpack is essentially a set of tools for developing Android applications and streamlining complicated processes.
   
• Lightweight in Nature: The ability to execute several coroutines on a single thread without blocking the thread in which the coroutine is executing is made possible by the support for suspension.
   
• Integrated cancellation support: Coroutine cancellation is interactive. A coroutine must be cooperative in order to be cancellable; otherwise, it will wait for the coroutine to complete. There are two ways to use suspending functions with Kotlin to build a coroutine cancellable. 
  
  
  • First is CoroutineScope.isActive boolean flag. 
  • Second is cancellable coroutines such as delay(), yield(), etc.
     
• Lesser memory leaks: Because Kotlin coroutines stick to organised concurrency, there are far fewer memory leaks in Kotlin. Many coroutines are started during the implementation, and the organised concurrency takes care of them to prevent loss or leakage.

Example of Coroutines

Coroutine helps to write better and more readable code. It performs all the tasks like a thread can. Below is an example of using coroutine in Kotlin. In this, we have made use of the launch function, which helps us call the show() method that we have defined. In this, we have printed a statement with an asynchronous operation delay and then printed the welcome statement. 

import kotlin.concurrent.thread

suspend fun show(str: String){
println("Hello, $str")
delay(100)
println("Welcome", $str")
}
fun main() = runBlocking{
val user = launch{ show("Ninja")}
}

Output

Hello Ninja
Welcome Ninja

Scopes and Builders for Coroutines Kotlin

We can only run suspending functions in coroutine scopes launched by coroutine builders like launch{}.

To begin a new coroutine and define the necessary scope to limit the lifespan of the coroutine, we utilize a coroutine builder. The lifecycle methods for coroutines provided by the coroutine scope let us start and stop them.

Three coroutine builders in Kotlin 

• launch{} 
• runBlocking{}
• async{} 

Exception Handling

With Launch

The exceptions thrown inside a launch-started coroutine are often displayed to the console rather than need to be handled. As uncaught exceptions, they are handled.

They may still be handled, though, by deploying a CoroutineExceptionHandler.

Code Implementation

import kotlinx.coroutines.*

fun main() = runBlocking {
    val excepHandl = CoroutineExceptionHandler { _, exception ->
        println("$exception saved !")
    }
    val work = GlobalScope.launch(excepHandl) {
        throw UnsupportedOperationException()
    }
    work.join()
}

Output

With Async

In this, we will be using Asynchronous to implement the code.

Code Implementation

import kotlinx.coroutines.*

fun main() = runBlocking {
    val timeDeff = GlobalScope.async {
        
        // Putting some logic here.
        throw UnsupportedOperationException()
    }
    try {
        // Here, the exception is thrown.
        timeDeff.await() 
        println("No output")
        } 
        
        // If error then catch will run.
        catch (e: UnsupportedOperationException) {
        println("UnsupportedOperationException saved !")
    }
}

Output

Executing in Background

Run the programme in the background.

Code Implementation

import kotlinx.coroutines.*

fun main() {
    println("The main code launches.")
    GlobalScope.launch {
        println("Beginning of background processing.")
        delay(300L)
        println("Background processing is complete.")
    }
    
    println("The main code resumes.")
    runBlocking {
        delay(600L)
        println("The main code has ended.")
    }
}

Output

Must Read Elvis Operator Kotlin

Frequently Asked Questions

What are Coroutines in Kotlin?

A coroutine is a feature of Kotlin. It is highly effective and can perform all tasks that a thread can. They are small, light threads that make it easier to develop asynchronous, responsive code that maintains the speed of demanding tasks like network calls and prevents blocking.

What are the advantages of Kotlin coroutines?

Kotlin coroutines help in writing well-defined, readable and efficient code. It helps simplify concurrent programming with the use of keywords like suspend, launch, join, and many more. Coroutines in Kotlin can handle the exceptions thrown in code. Coroutines are also less weight than threads, which gives more efficiency in running codes. 

What is the function of a coroutine?

The main function of coroutine is to manage asynchronous operations. It helps in writing asynchronous code, which in reality looks like synchronous code.  It also helps in pausing some functions without disturbing the flow of running code. You can easily run and manage code through coroutines.

Q. How many types of coroutines are in Kotlin?

Scopes in coroutines are basically restrictions applied on coroutines execution. There are three types of scopes in coroutines: global scope, ViewModel scope, and lifecycle scope.

Q. What is the difference between threads and coroutines?

Although both threads and coroutines help in execution bhut they have major differences. Threads are designed to maximize the usage of the CPU, whereas coroutines help in concurrency. Coroutines can easily handle the exceptions, whereas threads, it is challenging and complex. 

Conclusion

This article briefly discussed Corotines Kotlin and also covered scopes and builders for Coroutines Kotlin with Exception handling code implementation. Refer to the following articles to learn more:

• Kotlin Multiplatform.
   
• Sealed class in Kotlin.
   
• Companion Object in Kotlin.
   

Also, check out some of the Guided Paths available on Coding Ninjas Studio on topics such as the Basics of C++, Operating Systems, and Computer Networks, along with some Interview Experiences and Interview Bundles for placement preparation.