Asynchronous Programming in Practice with Kotlin: Real Examples and Optimization

#coroutines #async #programming #kotlin

1 – Introduction

Understanding the concepts of asynchronous programming is essential, but applying these concepts in real-world scenarios is where things really come to life. In this article, we will explore practical examples of how asynchronous programming can be used to optimize tasks and improve the performance of Kotlin applications .

We will use the examples from Synchronous vs. Asynchronous Café as a basis, showing the benefits of thinking asynchronously to solve everyday problems for a developer.

2 – Problem Review: Blocking Tasks

In a synchronous workflow, each task depends on the completion of the previous one. This means that the total execution time is the sum of the time of all tasks. On the other hand, asynchronous programming allows multiple tasks to be performed simultaneously, drastically reducing the total execution time.

Example: Brewing Synchronous Coffee

import kotlinx.coroutines.*

fun main() = runBlocking {
    makeSynchronousCafe()
    println("Coffee finished.")
}

suspend fun makeSynchronousCafe() {
    println("Getting water...")
    delay(1000) // Simulates the time to get the water
    println("Boiling water...")
    delay(2000) // Simulates the time to boil water
    println("Making coffee...")
    delay(1000) // Simulates the time to brew the coffee
}

Console Output

Getting the water...
Boiling water...
Making coffee...
Coffee finished.

Problem: All tasks are done in sequence. Total execution time is 4 seconds.

3 – Solution: Asynchronous Coffee

With asynchronous programming, we can perform parallel tasks, such as boiling water while preparing the filter, reducing the total execution time.
Example: Brewing Asynchronous Coffee

import kotlinx.coroutines.*

fun main() = runBlocking {
    val water = async { boilWater() }
    val filter = async { prepareFilter() }

    water.await() // Wait for the water to be ready
    filter.await() // Wait for the filter to be ready

    println("Making coffee...")
    delay(1000) // Simulates the time to brew the coffee
    println("Coffee finished.")
}

suspend fun boilWater() {
    println("Getting water...")
    delay(1000) // Simulates the time to get the water
    println("Boiling water...")
    delay(2000) // Simulates the time to boil water
}

suspend fun prepareFilter() {
    println("Preparing the filter and powder...")
    delay(1500) // Simulates the time to prepare the filter
}

Console Output

Getting the water...
Preparing the filter and powder...
Boiling water...
Making coffee...
Coffee finished.

4 – Real Cases of Asynchronous Programming

4.1 – Loading Data into Applications

Imagine an application that needs to load data from multiple APIs to build an interface.
With synchronous programming, each request would be made one after the other, increasing the waiting time. Using coroutines , all requests can be made simultaneously.

import kotlinx.coroutines.*

fun main() = runBlocking {
    val api1 = async { loadApiData("API 1") }
    val api2 = async { loadApiData("API 2") }

    println("Loading data...")
    println(api1.await())
    println(api2.await())
}

suspend fun loadApiData(api: String): String {
    delay(2000) // Simulates API response time
    return "$api: Data loaded"
}

4.2 - File Processing

When processing multiple large files, such as logs or images, coroutines can help divide and parallelize the work, reducing the overall processing time.

import kotlinx.coroutines.*

fun main() = runBlocking {
    val files = listOf("File1.txt", "File2.txt", "File3.txt")

        .map files { file ->
        launch { processFile(file) }
    }
}

suspend fun processFile(name: String) {
    println("Processing $name...")
    delay(1500) // Simulates processing time
    println("$name processed!")
}

5 – Benefits of Thinking Asynchronously

Time efficiency: Parallel tasks reduce total execution time.
Better user experience: More responsive and faster apps.
Optimal use of resources: Makes better use of available processing power.

6 – Conclusion

Asynchronous programming is an essential skill for any developer who wants to build efficient and modern applications. Using coroutines in Kotlin allows you to handle complex tasks in a simple and scalable way.

Summary:

The coffee example shows how parallel tasks optimize execution time.
Real-world cases like API loading and file processing highlight the practical benefits of coroutines .

In the next article, we will discuss how to integrate these concepts with Flow and how to further optimize your asynchronous programming.

Reference
Official Kotlin documentation on coroutines