Kotlin Coroutines And Threading Fundamentals
In this article, you will learn the fundamentals of threading, background processing, and of course Kotlin coroutines with a simple android specific practical example.
We are already using something called Blocking Calls knowingly or unknowingly in our code.
Blocking calls(Synchronous):
Well, A blocking call is when you call a function and for that, you have to wait for that function to finish before you continue executing the other functions. That is also called synchronous calls.
Non-blocking calls(Asynchronous):
A function can also be non-blocking. It’s also called Asynchronous. These calls do not need to be called immediately like synchronous calls. It runs parallel with other codes. That’s non-blocking as you don’t have to wait for the results before you continue executing the other functions.
Simple examples of Asynchronous call:
Listen to a podcast or music while you are walking. Doing multiple things in parallel.
Simple examples of Synchronous call:
Driving a car. Doing a single task at a time.
So in your Kotlin programs, performing heavy operations like network calls, interacting with Database/Device file system, etc, etc. You need to execute those tasks in the background thread. That’s means you should consider using the Asynchronous approach. If you perform those heavy operations in the UI/Main thread(Synchronous way). It will block your UI, freeze apps, app gonna be non-responsive, or even crash your app. This isn’t a good user experience. There is a high chance that users will uninstall your apps.
For using the Asynchronous approach to your apps. You need to use something called a thread.
Now, what are threads?
- Small piece of programs that runs independently.
- Each thread has some tasks to finish.
Every Android App has it’s Main Thread. It’s also called the UI thread. We use this thread to draw the user interface like TextView, EditText, Button, etc. UI thread needs to be fast. And should avoid using Non-blocking calls(Asynchronous) to it for not to freeze the UI as discussed earlier.
To achieve the Asynchronous(non-blocking) calls in Android developers uses an approach called background processing.
Background processing is when you move a data processing operation to a different thread so that the main thread is free. There are many different ways to do non-blocking task using background processing in Android like:
For example, Services are good for running long-running operations and WorkManager is good for the task that should be running in a specific condition like when you are connected to Wifi. All the above-mentioned approach some times not too good to perform background process work. For those reasons here come the Kotlin Coroutines to rescue.
To understand Kotlin Coroutines and its benefits you need to have a good knowledge of Threads and How the background processing works.
Kotlin Coroutines:
- Coroutines are Kotlin features that allow you to surround your blocking calls(Synchronous) codes in non-blocking(Asynchronous) constructs.
- A coroutine is like a function or a call which by default runs Asynchronously in parallel with others.
- Performing Asynchronously task using many other background concepts as mentioned earlier, required a lot of code to write. However, using Coroutines we can write clean and less code.
- Coroutines look exactly like regular blocking code. But it’s unblocking and lets you write short and understandable code.
Pretty Interesting Right?
Nowadays in Android background processing like Networking, Database Operations, File systems. Coroutines are getting popular because of simplicity and good performance. So it’s very important to understand the fundamentals of it.
Enough theory. Let’s practice some fundamentals of Threads and Coroutine now.
Create an Empty Android studio project from scratch. And of course select Kotlin as language. Add internet permission in Manifest.xml and add an ImageView in the layout file.
or
Check out the starter project(master branch) in your IDE. And proceed with the rest of the article.
YOU CAN ALSO DOWNLOAD THE ENTIRE PROJECT, SWITCH BETWEEN THE BRANCHES AND THEN GO THROUGH THE ARTICLE.
In this App, we gonna be downloading an image from the Internet using Http connection from an URL. Then transfer the data using the Input(receiving) stream. Using stream we can slowly load the image and display it in the ImageView once it downloaded.
In MainActivity.kt write the following code:
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val imageUrl = URL("https://developer.android.com/images/kotlin/cards/kotlin-bootcamp.png")
val httpConnection = imageUrl.openConnection() as HttpURLConnection
httpConnection.doInput = true // for receiving data
httpConnection.connect()
val inputStream = httpConnection.inputStream
val bitmapImage = BitmapFactory.decodeStream(inputStream)
imageView.setImageBitmap(bitmapImage)
}
}If you run the code now your app will crash & you get NetworkOnMainThreadException:
This exception happens because the code ran on Main Thread. Because it’s a network call it should run that expensive operation like network call off the main thread. As I explained above there are many ways available for performing expensive tasks using background processing in Android that allows us to perform operations in the background thread. That we will do next:
1. Using Simply Runnable:
Wrap the previous code inside Runnable for running the code off the main thread:
Thread(Runnable {
val imageUrl = URL("https://developer.android.com/images/kotlin/cards/kotlin-bootcamp.png")
val httpConnection = imageUrl.openConnection() as HttpURLConnection
httpConnection.doInput = true
httpConnection.connect()
val inputStream = httpConnection.inputStream
val bitmapImage = BitmapFactory.decodeStream(inputStream)
imageView.setImageBitmap(bitmapImage)
}).start()That seems it should work. Right? But the app crashes this time as well.
Why did that happen?
Only the main thread(or UI thread) can update the UI and show the image. If we try to do that from the background thread as we did previously. We will get an error/exception.
That means if we retrieved something from the background or some other thread we need to send the result back to the main thread/UI thread. That process called posting to the main thread.
Let us see how to do that using multiple ways:
- Using runOnUiThread block:
Thread(Runnable {
val imageUrl = URL("https://developer.android.com/images/kotlin/cards/kotlin-bootcamp.png")
val httpConnection = imageUrl.openConnection() as HttpURLConnection
httpConnection.doInput = true
httpConnection.connect()
val inputStream = httpConnection.inputStream
val bitmapImage = BitmapFactory.decodeStream(inputStream)
runOnUiThread {
imageView.setImageBitmap(bitmapImage)
}
}).start()Now you can see the image fetched successfully from the URL. (app screenshot).
runOnUiThread waits for the main thread to receive the signal and then runs the block of code with the braces.
- Using Handler and Main thread looper:
The main thread looper handles messages for the main thread and loops through the signal and processes them. looper sends the message to the main thread then the code executes.
Handler sends messages to looper for execute. It connects between signals and threads.
val mainLooper = Looper.getMainLooper()
Thread(Runnable {
val imageUrl = URL("https://developer.android.com/images/kotlin/cards/kotlin-bootcamp.png")
val httpConnection = imageUrl.openConnection() as HttpURLConnection
httpConnection.doInput = true
httpConnection.connect()
val inputStream = httpConnection.inputStream
val bitmapImage = BitmapFactory.decodeStream(inputStream)
Handler(mainLooper).post {
imageView.setImageBitmap(bitmapImage)
}
}).start()Those methods work fine but they are not good solutions because:
#1. We need to create a new thread every time we send data to the background.
#2. Every time we need to post data back to the main thread using the handler.
This way we allocate lots of memory. Each object in Kotlin takes memory to create and threads take more memory even a few megabytes. Imagine you are fetching lots of data from the network and creating lots of threads and handlers. This will execute your program very slowly or even freeze your apps which is not good in terms of performance. It’s really annoying to create lots of threads each time we perform heavy operations.
SOURCE CODE (UsingThreads branch)
Here comes the Kotlin Coroutines to rescue us from that:
Now we know something about Threads and background process, posting results in the main thread. With that knowledge in our back. We will now proceed with Kotlin Coroutine to display an image in the UI thread.
Kotlin coroutine lets you do background processing and posting to the main thread in so simple steps.
Coroutines:
- Functions which runs parallel.
- Coroutines are asynchronous by default.
- It can be canceled once it started.
- It also can be suspended. Which means it can pause or resume at any point in time.
We need CoroutineScope and CoroutineBuilder to start Coroutine:
- CoroutineScope: It attaches the coroutine to the lifecycle. If you do not use CoroutineScope, you can easily create memory leaks or coroutine which never ends. Using CoroutineScope you can tell how long the Coroutine can live.
- CoroutineBuilder: To start coroutine you need CoroutineBuilder. Builder launches coroutine and wraps code similar using Threads & Runnable that we used earlier while fetching images.
Coroutine by default runs off the main thread. If you want to switch the thread Kotlin has Dispatchers to do that for you.
Dispatchers: It’s similar to the Handler and Looper where you can use different dispatches to switch the thread. Dispatchers define which threads or ThreadPool coroutine will use.
ThreadPool: It is a set of threads that can be distributed across works that you want your program to finish. It’s called pool because all the thread is pooled together as the mentioned reason.
Now it’s time to apply them in our sample app
As mentioned we need two things to launch a coroutine:
- CoroutineScope for binding the coroutine to the lifecycle.
- CoroutineBuilder to launch it.
There are many different builders and CoroutineScope to use. One of the simplest scope and builder to use is GlobalScope and launch() Builder.
GlobalScope: It is called global because it lives as long as your application does.
First, add Coroutine dependency in app-level Build.gradle file:
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.2"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.2"coroutine-core dependency gives you core coroutine functionality.
coroutine-android dependency gives you android specifics threading functionality.
in MainActivity.kt
Replace the thread creation code with this:
val mainLooper = Looper.getMainLooper()
GlobalScope.launch {
val imageUrl = URL("https://developer.android.com/images/kotlin/cards/kotlin-bootcamp.png")
val httpConnection = imageUrl.openConnection() as HttpURLConnection
httpConnection.doInput = true
httpConnection.connect()
val inputStream = httpConnection.inputStream
val bitmapImage = BitmapFactory.decodeStream(inputStream)
Handler(mainLooper).post {
imageView.setImageBitmap(bitmapImage)
}
}Run the App. See the app runs fine. But there is no way that coroutine knows in which thread it should run. It just uses DefaultDispatcher worker thread. launch and GlobalScope component does lots of work behind the scene. GlobalScope does not hold any Dispatchers.
Time to use Dispatchers for that:
There are four different dispatchers. We will focus on the first two here:
- Dispatchers.IO: Used for input/output work. e.g. network call.
- Dispatchers.Main: Post to the main thread. for example when you update the UI.
- Dispatchers.Default
- Dispatchers.Unconfined
Time to apply those concepts in our sample app. Replace the previous code with this:
GlobalScope.launch { val imageUrl = URL("https://developer.android.com/images/kotlin/cards/kotlin-bootcamp.png")
val httpConnection = imageUrl.openConnection() as HttpURLConnection
httpConnection.doInput = true
httpConnection.connect()
val inputStream = httpConnection.inputStream
val bitmapImage = BitmapFactory.decodeStream(inputStream)
runOnUiThread {
imageView.setImageBitmap(bitmapImage)
}
}
Run the App. The app should work fine…
Now add some log statement in code:
As you can see in the second log statement the code runs in DefaultDispatcher worker thread.
Dispatchers.IO:
Now replace GlobalScope.launch with GlobalScope.launch(Dispatchers.IO). You will get the same DefaultDispatcher-worker-1 thread in the Logcat. That is because DefaultDispatcher and DefaultDispatcher.IO dispatcher shares threads between the pools.
Now you can say that if both do the work in the same thread then why to use DefaultDispatcher.IO?
Well, IO Dispatchers has just 64 threads limit while default dispatch has 4 threads limit. If you have a small processor having an extra thread in the IO Dispatchers is a big plus if you are performing heavy tasks in the background.
Dispatchers.Main:
To post the result in the main thread in our app. First, remove the runOnUiThread{} from MainActivity.kt
To post the result to the main thread using coroutine we need to launch a nested coroutine. If you check hint of the launch scope you can see that the code is inside CoroutineScope.
That means we can launch another coroutine within this one.
MainActivity.kt:
GlobalScope.launch(Dispatchers.IO) {
val imageUrl = URL("https://developer.android.com/images/kotlin/cards/kotlin-bootcamp.png")
val httpConnection = imageUrl.openConnection() as HttpURLConnection
httpConnection.doInput = true
httpConnection.connect()
val inputStream = httpConnection.inputStream
val bitmapImage = BitmapFactory.decodeStream(inputStream)
launch(Dispatchers.Main) {
imageView.setImageBitmap(bitmapImage)
}
}Run the app one last time. Huhhh The app works as expected.
SOURCE CODE (UsingCoroutine branch)
NOW YOU KNOW HOW TO DO BACKGROUND PROCESSING AND POST THE RESULT BACK TO MAIN THREAD WITH SIMPLE SWITCHING TECHNIQUE USING COROUTINES WITH JUST FEW SIMPLE STEPS.
If you enjoyed reading the article give it a clap!
