DEV Community: Comunidade Dev Space

Optimizing Asynchronous Programming with Flows in Kotlin: Introduction to Flow

Alan Gomes — Thu, 27 Mar 2025 08:00:00 +0000

1 – Introduction

As the complexity of applications grows, handling multiple asynchronous events in real time becomes essential. To this end, Kotlin offers a powerful tool called Flow, which simplifies the management of asynchronous data flows.

In this article, we will explore:

What is a Flow and how does it differ from other approaches like suspend and async .
Real use cases of Flow.
Tools like Turbine to test data flows.

2 – What is a `Flow`?

Kotlin Flow is a tool for handling asynchronous data flows. It works like a pipeline that emits values over time, allowing you to handle data streams efficiently.

Main Features:

Asynchronous: Flow emits values in a non-blocking manner.
Cold Stream : A Flow only starts emitting values when there is a "sink" (i.e. when someone consumes the data).
Cancellable: If the collector is canceled, the flow is also automatically canceled.

3 – Creating a `Flow`

Simple Example of a `Flow`

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val flow = flow {
        for (i in 1..3) {
            emit(i) // Emits a value
            delay(1000) // Simulates a delay between emissions
        }
    }

    flow.collect { value ->
        println("Received: $value")
    }
}

Console Output

Received: 1
Received: 2
Received: 3

Explanation:

emit: Sends values to the stream.
collect: Consumes the values emitted by the stream.

4 – Comparison: Flow vs. Other Approaches

Appearance	Flow	suspend	async
Continuous data flow	Yes	No	No
Multiple values	Yes	No (only one value per call)	No (returns a single value).
Cancellable	Yes	Yes	Yes
Typical example	Event streams	Simple asynchronous calls	Parallel computations.

5 – Transforming Data with `Flow`

The real power of Flow lies in its ability to transform the data output with operators.

Example: Using operators like `map` and `filter`

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val flow = flow {
        for (i in 1..5) {
            emit(i)
        }
    }

    flow
        .filter { it % 2 == 0 } // Filter even values
        .map { it * 10 } // Multiplies the values by 10
        .collect { value ->
            println("Transformed: $value")
        }
}

Console Output

Transformed: 20
Transformed: 40

6 – Testing Flows with Turbine

Turbine is a library that facilitates the validation of values emitted by a Flow.

Example with Turbine

import app.cash.turbine.test
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.test.*

fun main() = runTest {
// Creates a stream that emits two values with a delay between them
    val flow = flow {
        println("Emitting value 1")
        emit(1) // Emit the first value
        delay(500) // Wait 500ms
        println("Emitting value 2")
        emit(2) // Emit the second value
    }

// Test the flow
    flow.test {
        val firstValue = awaitItem() // Wait for the first value
        println("Value received from stream: $ firstValue ")
        assert(firstValue == 1) // Validates the first value

        val secondValue = awaitItem() // Wait for the second value
        println("Value received from stream: $ secondValue ")
        assert(secondValue == 2) // Validates the second value

        awaitComplete() // Check if the stream has completed
        println("Flow completed successfully!")
    }
}

Expected departure at terminal

Emitting value 1
Value received from stream: 1
Emitting value 2
Value received from stream: 2
Flow completed successfully!

7 – Real Use Cases of `Flow`

7.1 – Real Time Update

In a chat application, you can use a Flow to stream new messages to the user interface as they arrive from the server.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val messages = flow {
        val newMessages = listOf("Hi", "How are you?", "See you soon!")
        for (message in newMessages) {
            emit(message)
            delay(1000) // Simulates interval between messages
        }
    }

    messages.collect { message ->
        println("New message: $message")
    }
}

7.2 – Batch Data Processing

Imagine a system that needs to process large batches of data at regular intervals. Flow makes this implementation easy.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val batchFlow = flow {
        val lots = listOf("Lot1", "Lot2", "Lot3")
        for (lot in lots) {
            issue(batch)
            delay(2000) // Simulates processing time
        }
    }

    batchFlow.collect { lot ->
        println("Processing: $batch")
    }
}

8 – Conclusion

Flow is a powerful tool for handling asynchronous data in Kotlin , allowing you to emit, transform, and consume values in real time. It is essential for building modern applications, especially in scenarios that require handling continuous streams of events.

Summary:

Flow is ideal for continuous, cancelable data streams.
Operators like map and filter make it easier to transform the outputted data.
Tools like Turbine simplify flow testing.

References:
Official Kotlin documentation on coroutines
Turbine Documentation

Otimizando Programação Assíncrona com Fluxos no Kotlin: Introdução ao `Flow`

Alan Gomes — Thu, 27 Mar 2025 08:00:00 +0000

1 – Introdução

À medida que a complexidade das aplicações cresce, lidar com múltiplos eventos assíncronos em tempo real se torna essencial. Para isso, o Kotlin oferece uma poderosa ferramenta chamada Flow, que simplifica o gerenciamento de fluxos de dados assíncronos.

Neste artigo, exploraremos:

O que é um Flow e como ele difere de outras abordagens como suspend e async.
Casos reais de uso de Flow.
Ferramentas como o Turbine para testar fluxos de dados.

2 – O Que é um `Flow`?

Um Flow no Kotlin é uma ferramenta para lidar com fluxos de dados assíncronos. Ele funciona como um pipeline que emite valores ao longo do tempo, permitindo que você lide com streams de dados de forma eficiente.

Características principais:

Assíncrono: O Flow emite valores de forma não bloqueante.
Cold Stream: Um Flow só começa a emitir valores quando há um "coletor" (ou seja, quando alguém consome os dados).
Cancelável: Se o coletor for cancelado, o fluxo também é cancelado automaticamente.

3 – Criando um `Flow`

Exemplo Simples de um `Flow`

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val fluxo = flow {
        for (i in 1..3) {
            emit(i) // Emite um valor
            delay(1000) // Simula um intervalo entre emissões
        }
    }

    fluxo.collect { valor ->
        println("Recebido: $valor")
    }
}

Saída no console

Recebido: 1
Recebido: 2
Recebido: 3

Explicação:

emit: Envia valores para o fluxo.
collect: Consome os valores emitidos pelo fluxo.

4 – Comparação: Flow vs. Outras Abordagens

Aspecto	Flow	suspend	async
Fluxo de dados contínuo	Sim	Não	Não
Multiplos valores	Sim	Não (apenas um valor por chamada)	Não (retorna um único valor).
Cancelável	Sim	Sim	Sim
Exemplo típico	Streams de eventos	Chamadas assíncronas simples	Cálculos paralelos.

5 – Transformando Dados com `Flow`

O verdadeiro poder do Flow está em sua capacidade de transformar os dados emitidos com operadores.

Exemplo: Usando operadores como `map` e `filter`

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val fluxo = flow {
        for (i in 1..5) {
            emit(i)
        }
    }

    fluxo
        .filter { it % 2 == 0 } // Filtra valores pares
        .map { it * 10 } // Multiplica os valores por 10
        .collect { valor ->
            println("Transformado: $valor")
        }
}

Saída no console

Transformado: 20
Transformado: 40

6 – Testando Fluxos com Turbine

O Turbine é uma biblioteca que facilita a validação de valores emitidos por um Flow.

Exemplo com Turbine

import app.cash.turbine.test
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.test.*

fun main() = runTest {
    // Cria um fluxo que emite dois valores com um atraso entre eles
    val fluxo = flow {
        println("Emitindo valor 1")
        emit(1) // Emite o primeiro valor
        delay(500) // Aguarda 500ms
        println("Emitindo valor 2")
        emit(2) // Emite o segundo valor
    }

    // Testa o fluxo
    fluxo.test {
        val primeiroValor = awaitItem() // Aguarda o primeiro valor
        println("Valor recebido do fluxo: $primeiroValor")
        assert(primeiroValor == 1) // Valida o primeiro valor

        val segundoValor = awaitItem() // Aguarda o segundo valor
        println("Valor recebido do fluxo: $segundoValor")
        assert(segundoValor == 2) // Valida o segundo valor

        awaitComplete() // Verifica se o fluxo foi concluído
        println("Fluxo concluido com sucesso!")
    }
}

Saída esperada no terminal

Emitindo valor 1
Valor recebido do fluxo: 1
Emitindo valor 2
Valor recebido do fluxo: 2
Fluxo concluido com sucesso!

7 – Casos Reais de Uso do `Flow`

7.1 – Atualização em Tempo Real

Em um aplicativo de bate-papo, você pode usar um Flow para transmitir mensagens novas à interface do usuário conforme elas chegam do servidor.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val mensagens = flow {
        val novasMensagens = listOf("Oi", "Como você está?", "Até logo!")
        for (mensagem in novasMensagens) {
            emit(mensagem)
            delay(1000) // Simula intervalo entre mensagens
        }
    }

    mensagens.collect { mensagem ->
        println("Nova mensagem: $mensagem")
    }
}

7.2 – Processamento de Dados em Lotes

Imagine um sistema que precisa processar lotes de dados grandes em intervalos regulares. O Flow facilita essa implementação.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val fluxoDeLotes = flow {
        val lotes = listOf("Lote1", "Lote2", "Lote3")
        for (lote in lotes) {
            emit(lote)
            delay(2000) // Simula tempo de processamento
        }
    }

    fluxoDeLotes.collect { lote ->
        println("Processando: $lote")
    }
}

8 – Conclusão

O Flow é uma ferramenta poderosa para lidar com dados assíncronos no Kotlin, permitindo a emissão, transformação e consumo de valores em tempo real. Ele é essencial para construir aplicações modernas, especialmente em cenários que exigem a manipulação de streams contínuos de eventos.

Resumo:

O Flow é ideal para fluxos de dados contínuos e canceláveis.
Operadores como map e filter facilitam a transformação dos dados emitidos.
Ferramentas como o Turbine simplificam os testes de fluxos.

Referências:
Documentação oficial do Kotlin sobre corrotinas
Documentação do Turbine

Asynchronous Programming in Practice with Kotlin: Real Examples and Optimization

Alan Gomes — Thu, 20 Mar 2025 08:40:00 +0000

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

Programação Assíncrona na Prática com Kotlin: Exemplos Reais e Otimização

Alan Gomes — Thu, 20 Mar 2025 08:00:00 +0000

1 – Introdução

Entender os conceitos de programação assíncrona é essencial, mas aplicar esses conceitos em cenários reais é onde as coisas realmente ganham vida. Neste artigo, exploraremos exemplos práticos de como a programação assíncrona pode ser usada para otimizar tarefas e melhorar a performance de aplicações no Kotlin.

Usaremos como base os exemplos do Café Síncrono vs. Assíncrono, mostrando os benefícios de pensar assincronamente para resolver problemas do dia a dia de um desenvolvedor.

2 – Revisão do Problema: Tarefas Bloqueantes

Em um fluxo síncrono, cada tarefa depende da conclusão da anterior. Isso significa que o tempo total de execução é a soma do tempo de todas as tarefas. Por outro lado, a programação assíncrona permite que múltiplas tarefas sejam realizadas simultaneamente, reduzindo drasticamente o tempo total de execução.

Exemplo: Preparando Café Síncrono

import kotlinx.coroutines.*

fun main() = runBlocking {
    fazerCafeSincrono()
    println("Café finalizado.")
}

suspend fun fazerCafeSincrono() {
    println("Pegando a água...")
    delay(1000) // Simula o tempo para pegar a água
    println("Fervendo a água...")
    delay(2000) // Simula o tempo para ferver a água
    println("Passando o café...")
    delay(1000) // Simula o tempo para passar o café
}

Saída no console

Pegando a água...
Fervendo a água...
Passando o café...
Café finalizado.

Problema: Todas as tarefas são feitas em sequência. O tempo total de execução é 4 segundos.

3 – Solução: Café Assíncrono

Com a programação assíncrona, podemos realizar tarefas paralelas, como ferver a água enquanto preparamos o filtro, reduzindo o tempo total de execução.

Exemplo: Preparando Café Assíncrono

import kotlinx.coroutines.*

fun main() = runBlocking {
    val agua = async { ferverAgua() }
    val filtro = async { prepararFiltro() }

    agua.await() // Aguarda a água estar pronta
    filtro.await() // Aguarda o filtro estar pronto

    println("Passando o café...")
    delay(1000) // Simula o tempo para passar o café
    println("Café finalizado.")
}

suspend fun ferverAgua() {
    println("Pegando a água...")
    delay(1000) // Simula o tempo para pegar a água
    println("Fervendo a água...")
    delay(2000) // Simula o tempo para ferver a água
}

suspend fun prepararFiltro() {
    println("Preparando o filtro e o pó...")
    delay(1500) // Simula o tempo para preparar o filtro
}

Saída no console

Pegando a água...
Preparando o filtro e o pó...
Fervendo a água...
Passando o café...
Café finalizado.

4 – Casos Reais de Programação Assíncrona

4.1 – Carregamento de Dados em Aplicativos

Imagine um aplicativo que precisa carregar dados de múltiplas APIs para montar uma interface.

Com programação síncrona, cada requisição seria feita uma após a outra, aumentando o tempo de espera. Usando corrotinas, todas as requisições podem ser feitas simultaneamente.

import kotlinx.coroutines.*

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

    println("Carregando dados...")
    println(api1.await())
    println(api2.await())
}

suspend fun carregarDadosDeApi(api: String): String {
    delay(2000) // Simula o tempo de resposta da API
    return "$api: Dados carregados"
}

4.2 - Processamento de Arquivos

Ao processar múltiplos arquivos grandes, como logs ou imagens, corrotinas podem ajudar a dividir e paralelizar o trabalho, reduzindo o tempo total de processamento.

import kotlinx.coroutines.*

fun main() = runBlocking {
    val arquivos = listOf("Arquivo1.txt", "Arquivo2.txt", "Arquivo3.txt")

    arquivos.map { arquivo ->
        launch { processarArquivo(arquivo) }
    }
}

suspend fun processarArquivo(nome: String) {
    println("Processando $nome...")
    delay(1500) // Simula o tempo de processamento
    println("$nome processado!")
}

5 – Benefícios de Pensar Assincronamente

Eficiência de tempo: Tarefas paralelas reduzem o tempo total de execução.
Melhor experiência do usuário: Aplicativos mais responsivos e rápidos.
Uso ideal de recursos: Aproveita melhor o poder de processamento disponível.

6 – Conclusão

A programação assíncrona é uma habilidade essencial para qualquer desenvolvedor que deseja criar aplicações eficientes e modernas. Usar corrotinas no Kotlin permite que você lide com tarefas complexas de forma simples e escalável.

Resumo:

O exemplo do café mostra como tarefas paralelas otimizam o tempo de execução.
Casos reais, como carregamento de APIs e processamento de arquivos, destacam os benefícios práticos das corrotinas.

No próximo artigo, discutiremos como integrar esses conceitos com fluxos (Flow) e como otimizar ainda mais sua programação assíncrona.

Referência
Documentação oficial do Kotlin sobre corrotinas

Unit Testing with Coroutines in Kotlin: Tools and Best Practices

Alan Gomes — Thu, 13 Mar 2025 08:40:00 +0000

1 – Introduction

Testing asynchronous code can be challenging. Functions that use coroutines can have unpredictable behavior due to delays, concurrent execution, and context switches. Fortunately, Kotlin provides built-in tools and helper libraries to simplify unit testing with coroutines .

In this article, we will explore how to use tools like UnconfinedTestDispatcher, TestCoroutineScheduler, and the Turbine library to efficiently test coroutines and flows.

2 – The Problem of Testing Asynchronous Code

Testing asynchronous code is tricky because:

Coroutines can run in different threads or contexts.
Methods like delay or withTimeout introduce real waits that can slow down tests.
Flows depend on asynchronous events that need to be controlled.

Without the right tools, tests can become flaky or take longer than necessary.

3 - Kotlin Native Tools

3.1 – UnconfinedTestDispatcher

What is it? A dispatcher designed for testing that is not tied to specific threads.
Why use it? Allows you to run coroutines without context restrictions, making tests predictable.
Example:

import kotlinx.coroutines.*
import kotlinx.coroutines.test.*

fun main() = runTest {
    // The testScheduler is a TestCoroutineScheduler automatically provided by runTest .
// It manages virtual time for all coroutines in this test.
    val testDispatcher = UnconfinedTestDispatcher(testScheduler)

// We use testDispatcher to ensure that all operations share not only the same scheduler , but also the same dispatcher .
    withContext(testDispatcher) {
        println(" Running in UnconfinedTestDispatcher : ${Thread.currentThread().name}")
        delay(1000) // Simulates a virtual 1 second delay
        println("Finalizing in UnconfinedTestDispatcher .")
    }
}

3.2 – TestCoroutineScheduler

What is it? A scheduler that allows you to manually advance time in tests.
Why use it? To control time-based tasks (delay, withTimeout) without waiting for real time to pass.
Example:

import kotlinx.coroutines.*
import kotlinx.coroutines.test.*
import org.junit.Test

class CoroutinesTests {
    // Create a TestCoroutineScheduler manually
    private val scheduler = TestCoroutineScheduler()

    // Create a dispatcher based on the manual scheduler
    private var testDispatcher: TestDispatcher = UnconfinedTestDispatcher(scheduler)

    @Test
    fun testCoroutines() {
// Use runTest with the dispatcher configured
        runTest(testDispatcher) {
            println("Task started.")

// Launch a coroutine in the same dispatcher
            delay(1000) // Simulates a virtual 1 second delay
            println("Task completed.")

// Advance time virtually by 1 second
            scheduler.advanceTimeBy(1000)
        }
    }
}

Why do we need @Test?

The @Test annotation is used to mark a method as a test case, allowing it to be executed by JUnit.
Without @Test, the testCoroutines method would be treated as a normal method and would not appear as executable in the IDE.
When JUnit detects @Test, it:
1. Automatically instantiate the test class.
2. Execute the marked method, with all dependencies configured (such as scheduler and testDispatcher).

3.3 – runTest

What is it? A function that provides a controlled environment for running coroutines in tests.
Why use it? Simplifies the setup of asynchronous tests by replacing runBlocking in tests.
Example:

import kotlinx.coroutines.*
import kotlinx.coroutines.test.*

fun main() = runTest {
    println("Starting test.")
    delay(1000) // This does not delay the actual test
    println("Test completed.")
}

4 - Testing flows with the turbine library

For Flows, the Turbine library simplifies the collection and validation of emitted values.

4.1 – What is Turbine?

Turbine is a library designed specifically for testing flows in Kotlin , allowing you to validate emitted items and events like cancellation or completion.

Example with turbine:

import app.cash.turbine.test
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.test.runTest

fun main() = runTest {
    val flow = flow {
        emit(1)
        delay(1000)
        emit(2)
    }

    flow.test {
        val item1 = awaitItem()
        println("Received: $item1") // Display the first value on the terminal
        assert(item1 == 1) // Validate the first item

        val item2 = awaitItem()
        println("Received: $item2") // Display the second value on the terminal
        assert(item2 == 2) // Validate the second item

        awaitComplete() // Confirms that the flow has completed
        println("Flow completed !") // Indicates that the flow has finished
    }
}

5 – Tool Comparison

Tool	Function	When to use
UnconfinedTestDispatcher	Runs coroutines without context restrictions.	Simple tests that do not rely on real-time.
TestCoroutineScheduler	Manually controls timing in tests.	Tests with `delay`, `timeout`, or time events.
Turbine	Tests values emitted by `Flow`.	Flow-specific tests.

6 – Conclusion

Testing coroutines and flows in Kotlin can be challenging, but with the right tools, you can create fast, efficient, and reliable tests. Using UnconfinedTestDispatcher , TestCoroutineScheduler , and libraries like Turbine makes the process much simpler.

Summary:

Time tracking: Use TestCoroutineScheduler to manage delays and scheduling.
Test environments: runTest is the basis for asynchronous testing.
Flow Testing: Turbine is the ideal solution for validating flows.

Now that you know the best practices for testing coroutines in Kotlin , try applying them to your projects!

In the next article, we will discuss a little more about examples of asynchrony, just to explore the subject a little more and fix the content better.

References:
Official Kotlin documentation on coroutines
Turbine Documentation

Testes Unitários com Corrotinas no Kotlin: Ferramentas e Boas Práticas

Alan Gomes — Thu, 13 Mar 2025 08:00:00 +0000

1 – Introdução

Testar código assíncrono é, muitas vezes, um desafio. Funções que utilizam corrotinas podem ter comportamento imprevisível devido a atrasos, execução concorrente e mudanças de contexto. Felizmente, o Kotlin oferece ferramentas nativas e bibliotecas auxiliares para simplificar os testes unitários com corrotinas.

Neste artigo, exploraremos como usar ferramentas como UnconfinedTestDispatcher, TestCoroutineScheduler, e a biblioteca Turbine para testar corrotinas e fluxos de forma eficiente.

2 – O Problema de Testar Código Assíncrono

Testar código assíncrono é complicado porque:

Corrotinas podem ser executadas em diferentes threads ou contextos.
Métodos como delay ou withTimeout introduzem esperas reais que podem tornar os testes lentos.
Fluxos (Flow) dependem de eventos assíncronos que precisam ser controlados.

Sem as ferramentas corretas, testes podem se tornar inconsistentes (flaky) ou levar mais tempo do que o necessário.

3 – Ferramentas Nativas do Kotlin

3.1 – UnconfinedTestDispatcher

O que é? Um dispatcher projetado para testes que não está vinculado a threads específicas.
Por que usar? Permite executar corrotinas sem restrições de contexto, tornando os testes previsíveis.
Exemplo:

import kotlinx.coroutines.*
import kotlinx.coroutines.test.*

fun main() = runTest {
    // O testScheduler é um TestCoroutineScheduler fornecido automaticamente pelo runTest.
    // Ele gerencia o tempo virtual para todas as corrotinas neste teste.
    val testDispatcher = UnconfinedTestDispatcher(testScheduler)

    // Utilizamos o testDispatcher para garantir que todas as operações compartilhem além do mesmo scheduler, também o mesmo dispatcher.
    withContext(testDispatcher) {
        println("Executando no UnconfinedTestDispatcher: ${Thread.currentThread().name}")
        delay(1000) // Simula um atraso de 1 segundo virtual
        println("Finalizando no UnconfinedTestDispatcher.")
    }
}

3.2 – TestCoroutineScheduler

O que é? Um agendador que permite avançar o tempo manualmente em testes.
Por que usar? Para controlar tarefas baseadas em tempo (delay, withTimeout) sem esperar o tempo real passar.
Exemplo:

import kotlinx.coroutines.*
import kotlinx.coroutines.test.*
import org.junit.Test

class TestesCoroutines {
    // Cria um TestCoroutineScheduler manualmente
    private val scheduler = TestCoroutineScheduler()

    // Cria um dispatcher baseado no scheduler manual
    private var testDispatcher: TestDispatcher = UnconfinedTestDispatcher(scheduler)

    @Test
    fun testCoroutines() {
        // Usa runTest com o dispatcher configurado
        runTest(testDispatcher) {
            println("Tarefa iniciada.")

            // Lança uma corrotina no mesmo dispatcher
            delay(1000) // Simula um atraso de 1 segundo virtual
            println("Tarefa concluída.")

            // Avança o tempo virtualmente em 1 segundo
            scheduler.advanceTimeBy(1000)
        }
    }
}

Por que precisamos do @Test?

A anotação @Test é usada para marcar um método como um caso de teste, permitindo que ele seja executado pelo JUnit.
Sem o @Test, o método testCoroutines seria tratado como um método normal e não apareceria como executável no IDE.
Quando o JUnit detecta o @Test, ele:
1. Instancia automaticamente a classe de teste.
2. Executa o método marcado, com todas as dependências configuradas (como scheduler e testDispatcher).

3.3 – runTest

O que é? Uma função que fornece um ambiente controlado para executar corrotinas em testes.
Por que usar? Simplifica a configuração de testes assíncronos, substituindo runBlocking em testes.
Exemplo:

import kotlinx.coroutines.*
import kotlinx.coroutines.test.*

fun main() = runTest {
    println("Iniciando o teste.")
    delay(1000) // Isso não atrasa o teste real
    println("Teste finalizado.")
}

4 - Testando fluxos com a biblioteca turbine

Para fluxos (Flow), a biblioteca Turbine simplifica a coleta e validação de valores emitidos.

4.1 – O que é Turbine?

Turbine é uma biblioteca projetada especificamente para testar fluxos no Kotlin, permitindo validar os itens emitidos e eventos como cancelamento ou conclusão.

Exemplo com turbine:

import app.cash.turbine.test
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.test.runTest

fun main() = runTest {
    val fluxo = flow {
        emit(1)
        delay(1000)
        emit(2)
    }

    fluxo.test {
        val item1 = awaitItem()
        println("Recebido: $item1") // Exibe o primeiro valor no terminal
        assert(item1 == 1) // Valida o primeiro item

        val item2 = awaitItem()
        println("Recebido: $item2") // Exibe o segundo valor no terminal
        assert(item2 == 2) // Valida o segundo item

        awaitComplete() // Confirma que o fluxo foi concluído
        println("Fluxo concluido!") // Indica que o fluxo terminou
    }
}

5 – Comparação de Ferramentas

Ferramenta	Função	Quando usar
UnconfinedTestDispatcher	Executa corrotinas sem restrições de contexto.	Testes simples que não dependem de tempo real.
TestCoroutineScheduler	Controla tempo manualmente em testes.	Testes com `delay`, `timeout`, ou eventos de tempo.
Turbine	Testa valores emitidos por `Flow`.	Testes específicos de fluxos.

6 – Conclusão

Testar corrotinas e fluxos no Kotlin pode ser desafiador, mas com as ferramentas certas, é possível criar testes rápidos, eficientes e confiáveis. O uso de UnconfinedTestDispatcher, TestCoroutineScheduler, e bibliotecas como o Turbine torna o processo muito mais simples.

Resumo:

Controle de tempo: Use TestCoroutineScheduler para gerenciar atrasos e agendamentos.
Ambientes de teste: runTest é a base para testes assíncronos.
Testes de fluxo: Turbine é a solução ideal para validar fluxos.

Agora que você conhece as melhores práticas para testar corrotinas no Kotlin, experimente aplicá-las nos seus projetos!

No próximo artigo, iremos discorrer um pouquinho mais a respeito de exemplos de assincronia, somente para explorarmos o assunto um pouco mais e fixarmos o conteúdo melhor.

Utility and Execution Methods in Kotlin: Working with Coroutines

Alan Gomes — Thu, 06 Mar 2025 08:40:00 +0000

1 – Introduction

When working with coroutines in Kotlin , there are utility methods and execution methods that help you manage asynchronous tasks efficiently. These methods are essential tools for controlling:

The execution time of the tasks.
The context in which tasks are performed.
Starting and synchronizing multiple coroutines .

In this article, we will explore the most important methods, such as withTimeout, withContext, launch, async, and others, with practical examples to understand how and when to use them.

2 – Utility Methods

2.1 – withTimeout

What is it? Cancels the execution of a block of code if the timeout is reached.
When to use? To prevent asynchronous tasks from getting stuck indefinitely.
Example:

import kotlinx.coroutines.*

fun main( ) = runBlocking{
try {
        withTimeout ( 1000) { // 1 second timeout
            delay( 2000) // Simulates a long task
            println ( "Task completed!")
}
} catch (e: TimeoutCancellationException ) {
        println ( "Timeout reached! Task canceled.")
}
}

2.2 - withTimeoutOrNull

What is it? Similar to withTimeout , but instead of throwing an exception, it returns null if the timeout is reached.
When to use? To avoid using exceptions and handle timeout in a more controlled way.
Example:

import kotlinx.coroutines.*

fun main() = runBlocking {
    val result = withTimeoutOrNull(1000) { // 1 second timeout
        delay(2000) // Simulates a long task
        "Job completed!"
    }

    if (result == null) {
        println("Timeout reached! Returned null .")
    } else {
        println(result)
    }
}

2.3 – withContext

What is it? Changes the context of the coroutine (e.g.: changes the dispatcher ).
When to use? temporarily change the dispatcher within a coroutine .
Example:

import kotlinx.coroutines .*

fun main() = runBlocking {
    println(" Running on Default Dispatcher : ${Thread.currentThread().name}")

    withContext(Dispatchers.IO) {
        println(" Running in IO Dispatcher: ${Thread.currentThread().name}")
    }

    println("Back to Default Dispatcher : ${Thread.currentThread().name}")
}

2.4 – delay

What is it? Suspends the execution of a coroutine for a period of time, without blocking the thread.
When to use? To simulate time-consuming tasks or wait for a response.
Example:

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Starting task...")
    delay(1000) // Suspend for 1 second
    println("Task completed!")
}

2.5 – yield

What is it? Yields the current context, allowing other coroutines to run.
When to use? To improve cooperation between coroutines and avoid unnecessary blocking.
Example:

import kotlinx.coroutines.*

fun main() = runBlocking{
    launch {
        repeat(3) { i ->
            println(" Coroutine 1 - Iteration $i")
            yield() // Yield the context
        }
    }

    launch {
        repeat(3) { i ->
            println(" Coroutine 2 - Iteration $i")
            yield() // Yield the context
        }
    }
}

3 – Execution Methods

3.1 – launch

What is it? Creates a new coroutine and starts its execution immediately.
When to use? When you don't need to return a result from the coroutine .
Example:

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("Coroutine started!")
        delay(1000)
        println("Coroutine finished!")
    }
}

3.2 – async

What is it? Creates a new coroutine that returns a value (deferred).
When to use? For asynchronous tasks that return results.
Example:

import kotlinx.coroutines.*

fun main() = runBlocking {
    val result = async {
        delay(1000)
        "Result calculated!"
    }

    println("Waiting for result...")
    println("Result:${result.await()}")
}

3.3 – runBlocking

What is it? Executes coroutines in a blocking function.
When to use? Only in specific cases, such as small scripts or for quick testing.
Example:

import kotlinx.coroutines.*

fun main( ) = runBlocking {
    println("Starting runBlocking")
    delay(1000)
    println("Finalizing runBlocking")
}

4 – Comparison: Utility Methods vs. Execution Methods

Aspect	Utility Methods	Execution Methods
Main Function	Control time, context, and suspension.	Start and manage coroutines.
Return Value	Generally, they do not return values.	Some return values (e.g. `async`).
Main Examples	`withTimeout`, `delay`, `yield`	`launch`, `async`, `runBlocking`

5 – Conclusion

Utility and runner methods are indispensable tools in the Kotlin coroutine ecosystem. They allow you to control asynchronous execution in a precise, scalable, and efficient way.

Summary of Methods:

1. Utilities:

Timeout control: withTimeout, withTimeoutOrNull.
Context: withContext.
Suspension: delay, yield.

2. Execution:

launch for coroutines that do not return values.
async for coroutines that return results.
runBlocking to run coroutines in scripts or simple tests.

In the next article, we will explore how to efficiently test coroutines and flows with native tools and libraries like Turbine.

Reference
Official Kotlin documentation on coroutines

Métodos Utilitários e de Execução no Kotlin: Trabalhando com Corrotinas

Alan Gomes — Thu, 06 Mar 2025 08:00:00 +0000

1 – Introdução

Ao trabalhar com corrotinas no Kotlin, existem métodos utilitários e métodos de execução que ajudam a gerenciar tarefas assíncronas de forma eficiente. Esses métodos são ferramentas essenciais para controlar:

O tempo de execução das tarefas.
O contexto em que as tarefas são executadas.
O início e a sincronização de múltiplas corrotinas.

Neste artigo, exploraremos os métodos mais importantes, como withTimeout, withContext, launch, async, e outros, com exemplos práticos para entender como e quando usá-los.

2 – Métodos Utilitários

2.1 – withTimeout

O que é? Cancela a execução de um bloco de código se o tempo limite for atingido.
Quando usar? Para evitar que tarefas assíncronas fiquem presas indefinidamente.
Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    try {
        withTimeout(1000) { // Tempo limite de 1 segundo
            delay(2000) // Simula uma tarefa longa
            println("Tarefa concluída!")
        }
    } catch (e: TimeoutCancellationException) {
        println("Tempo limite atingido! Tarefa cancelada.")
    }
}

2.2 - withTimeoutOrNull

O que é? Semelhante ao withTimeout, mas em vez de lançar uma exceção, retorna null se o tempo limite for atingido.
Quando usar? Para evitar o uso de exceções e lidar com o timeout de forma mais controlada.
Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    val resultado = withTimeoutOrNull(1000) { // Tempo limite de 1 segundo
        delay(2000) // Simula uma tarefa longa
        "Tarefa concluída!"
    }

    if (resultado == null) {
        println("Tempo limite atingido! Retornou null.")
    } else {
        println(resultado)
    }
}

2.3 – withContext

O que é? Altera o contexto da corrotina (ex.: muda o dispatcher).
Quando usar? Para trocar o dispatcher de forma temporária dentro de uma corrotina.
Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Executando no Dispatcher Padrão: ${Thread.currentThread().name}")

    withContext(Dispatchers.IO) {
        println("Executando no Dispatcher IO: ${Thread.currentThread().name}")
    }

    println("De volta ao Dispatcher Padrão: ${Thread.currentThread().name}")
}

2.4 – delay

O que é? Suspende a execução de uma corrotina por um período de tempo, sem bloquear a thread.
Quando usar? Para simular tarefas demoradas ou esperar por uma resposta.
Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Iniciando a tarefa...")
    delay(1000) // Suspende por 1 segundo
    println("Tarefa concluída!")
}

2.5 – yield

O que é? Cede o contexto atual, permitindo que outras corrotinas sejam executadas.
Quando usar? Para melhorar a cooperação entre corrotinas e evitar bloqueios desnecessários.
Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        repeat(3) { i ->
            println("Corrotina 1 - Iteração $i")
            yield() // Cede o contexto
        }
    }

    launch {
        repeat(3) { i ->
            println("Corrotina 2 - Iteração $i")
            yield() // Cede o contexto
        }
    }
}

3 – Métodos de Execução

3.1 – launch

O que é? Cria uma nova corrotina e inicia sua execução imediatamente.
Quando usar? Quando você não precisa retornar um resultado da corrotina.
Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("Corrotina iniciada!")
        delay(1000)
        println("Corrotina finalizada!")
    }
}

3.2 – async

O que é? Cria uma nova corrotina que retorna um valor (deferred).
Quando usar? Para tarefas assíncronas que retornam resultados.
Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    val resultado = async {
        delay(1000)
        "Resultado calculado!"
    }

    println("Esperando o resultado...")
    println("Resultado: ${resultado.await()}")
}

3.3 – runBlocking

O que é? Executa corrotinas em uma função bloqueante.
Quando usar? Apenas em casos específicos, como scripts pequenos ou para testes rápidos.
Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Iniciando runBlocking")
    delay(1000)
    println("Finalizando runBlocking")
}

4 – Comparação: Métodos Utilitários vs. Métodos de Execução

Aspecto	Métodos Utilitários	Métodos de Execução
Função principal	Controlar tempo, contexto e suspensão.	Iniciar e gerenciar corrotinas.
Retorno de valor	Geralmente, não retornam valores.	Alguns retornam valores (ex.: `async`).
Exemplos principais	`withTimeout`, `delay`, `yield`.	`launch`, `async`, `runBlocking`.

5 – Conclusão

Os métodos utilitários e de execução são ferramentas indispensáveis no ecossistema de corrotinas do Kotlin. Eles permitem que você controle a execução assíncrona de maneira precisa, escalável e eficiente.

Resumo dos Métodos:

1. Utilitários:

Controle de tempo: withTimeout, withTimeoutOrNull.
Contexto: withContext.
Suspensão: delay, yield.

1. Execução:

launch para corrotinas que não retornam valores.
async para corrotinas que retornam resultados.
runBlocking para executar corrotinas em scripts ou testes simples.

No próximo artigo, exploraremos como testar corrotinas e fluxos de maneira eficiente com ferramentas nativas e bibliotecas como o Turbine.

Referência
Documentação oficial do Kotlin sobre corrotinas

Scopes in Kotlin: Controlling Lifecycle and Cancellation of Coroutines

Alan Gomes — Thu, 27 Feb 2025 08:00:00 +0000

1 – Introduction

Managing the lifecycle of coroutines is one of the most important aspects of asynchronous programming in Kotlin. To this end, Kotlin provides scopes: structures that help you control how and when coroutines run, as well as making it easy to cancel tasks when necessary.

In this article, we'll explore the main types of scopes in Kotlin and their differences. You'll see how choosing the right scope can simplify managing coroutines in your code.

2 – What are Scopes?

Scopes in Kotlin are "managers" of the coroutines lifecycle. They:

Determine where and how coroutines will be executed.
Control the life cycle of coroutines, including their cancellation.

Scope Types:

Class-based scopes: Used for long-term operations or associated with specific components, such as viewModelScope in Android.
Role-based scopes: Used for temporary and local operations, such as coroutineScope and supervisorScope.

3 – Class-Based Scopes

3.1 – CoroutineScope

What is it? It is the base interface for creating custom scopes. You can associate a CoroutineScope with a specific context (e.g. a Dispatcher) to manage coroutines.
When to use? To create custom scopes that control the lifecycle of multiple coroutines.
Example:

import kotlinx.coroutines.*

fun main() {
    val customScope = CoroutineScope(Dispatchers.Default)

    customScope.launch {
        println("Running inside CoroutineScope:${Thread.currentThread().name}")
    }
}

3.2 – viewModelScope

What is it? A special scope provided by the Android Jetpack library, designed for the lifecycle of ViewModels. When the ViewModel is destroyed, all coroutines associated with the viewModelScope are automatically canceled.
When to use?
To manage UI-associated coroutines on Android.
Example:

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch

class MyViewModel : ViewModel() {
    fun loadData() {
        viewModelScope.launch {
            println("Loading data into thread: ${Thread.currentThread().name}")
        }
    }
}

3.3 – backgroundScope

What is it? A scope designed for long-term operations that can continue even if the life cycle of the main component ends.
When to use?
For tasks that need to persist beyond their immediate lifecycle, such as background sync.
Example:

import kotlinx.coroutines.*

fun main() {
    val backgroundScope = CoroutineScope(Dispatchers.IO)

    backgroundScope.launch {
        println("Running in the background:${Thread.currentThread().name}")
    }
}

4 – Role-Based Scopes

4.1 – coroutineScope

What is it? A suspend function that creates a temporary scope. All coroutines within a coroutineScope share the same Job.
When to use? To ensure that all tasks within a block are completed or cancelled together.
Example:

import kotlinx.coroutines .*

suspend fun main() {
    coroutineScope {
        launch {
            println("Coroutine 1 running...")
        }
        launch {
            println("Coroutine 2 running...")
        }
    }
    println("All coroutines completed.")
}

4.2 – supervisorScope

What is it? Similar to coroutineScope, but with one crucial difference: failures in one coroutine do not affect the others within the scope.
When to use? To ensure that all tasks within a block are completed or cancelled together.
Example:

import kotlinx.coroutines.*

suspend fun main() {
    supervisorScope {
        launch {
            println("Coroutine 1 running...")
            throw RuntimeException("Error in Coroutine 1")
        }
        launch {
            println("Coroutine 2 running...")
        }
    }
    println("SupervisorScope completed.")
}

5 – Comparison: coroutineScope vs. supervisorScope

Appearance	coroutineScope	supervisorScope
Cancellation	Cancels all coroutines on failure.	Only the coroutine with the error is canceled.
Relationship between tasks	Coroutines dependent on each other.	Independent coroutines .
When to use	When all tasks must succeed.	When tasks can fail independently.

6 – Conclusion

Scopes are powerful tools in Kotlin for managing the lifecycle of coroutines. They help prevent resource leaks and make it easier to cancel unnecessary tasks.

Scope Summary:

CoroutineScope: For custom scopes.
viewModelScope: To manage coroutines bound to ViewModels in Android.
coroutineScope: For temporary scopes where all tasks depend on each other.
supervisorScope: For independent tasks. In the next article, we will explore utility methods and execution methods that you can use to further optimize your coroutines .

Reference
Official Kotlin documentation on coroutines

Escopos no Kotlin: Controlando Ciclo de Vida e Cancelamento de Corrotinas

Alan Gomes — Thu, 27 Feb 2025 08:00:00 +0000

1 – Introdução

Gerenciar o ciclo de vida de corrotinas é um dos aspectos mais importantes da programação assíncrona no Kotlin. Para isso, o Kotlin oferece escopos: estruturas que ajudam a controlar como e quando corrotinas são executadas, além de facilitar o cancelamento de tarefas quando necessário.

Neste artigo, exploraremos os principais tipos de escopos no Kotlin e suas diferenças. Você verá como escolher o escopo certo pode simplificar o gerenciamento de corrotinas no seu código.

2 – O Que São Escopos?

Escopos no Kotlin são "gestores" do ciclo de vida das corrotinas. Eles:

Determinam onde e como as corrotinas serão executadas.
Controlam o ciclo de vida das corrotinas, incluindo seu cancelamento.

Tipos de Escopos:

Escopos baseados em classes: Utilizados para operações de longo prazo ou associadas a componentes específicos, como viewModelScope em Android.
Escopos baseados em funções: Utilizados para operações temporárias e locais, como coroutineScope e supervisorScope.

3 – Escopos Baseados em Classes

3.1 – CoroutineScope

O que é? É a interface base para criar escopos personalizados. Você pode associar um CoroutineScope a um contexto específico (por exemplo, um Dispatcher) para gerenciar corrotinas.
Quando usar? Para criar escopos customizados que controlam o ciclo de vida de várias corrotinas.
Exemplo:

import kotlinx.coroutines.*

fun main() {
    val customScope = CoroutineScope(Dispatchers.Default)

    customScope.launch {
        println("Executando dentro do CoroutineScope: ${Thread.currentThread().name}")
    }
}

3.2 – viewModelScope

O que é? Um escopo especial fornecido pela biblioteca Android Jetpack, projetado para o ciclo de vida de ViewModels. Quando o ViewModel é destruído, todas as corrotinas associadas ao viewModelScope são automaticamente canceladas.
Quando usar?
Para gerenciar corrotinas associadas à UI no Android.
Exemplo:

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch

class MyViewModel : ViewModel() {
    fun loadData() {
        viewModelScope.launch {
            println("Carregando dados na thread: ${Thread.currentThread().name}")
        }
    }
}

3.3 – backgroundScope

O que é? Um escopo projetado para operações de longo prazo que podem continuar mesmo se o ciclo de vida do componente principal terminar.
Quando usar?
Para tarefas que precisam persistir além do ciclo de vida imediato, como sincronização em segundo plano.
Exemplo:

import kotlinx.coroutines.*

fun main() {
    val backgroundScope = CoroutineScope(Dispatchers.IO)

    backgroundScope.launch {
        println("Executando no background: ${Thread.currentThread().name}")
    }
}

4 – Escopos Baseados em Funções

4.1 – coroutineScope

O que é? Uma função suspensa que cria um escopo temporário. Todas as corrotinas dentro de um coroutineScope compartilham o mesmo Job.
Quando usar? Para garantir que todas as tarefas dentro de um bloco sejam concluídas ou canceladas em conjunto.
Exemplo:

import kotlinx.coroutines.*

suspend fun main() {
    coroutineScope {
        launch {
            println("Corrotina 1 executando...")
        }
        launch {
            println("Corrotina 2 executando...")
        }
    }
    println("Todas as corrotinas concluídas.")
}

4.2 – supervisorScope

O que é? Semelhante ao coroutineScope, mas com uma diferença crucial: falhas em uma corrotina não afetam as outras dentro do escopo.
Quando usar? Para garantir que todas as tarefas dentro de um bloco sejam concluídas ou canceladas em conjunto.
Exemplo:

import kotlinx.coroutines.*

suspend fun main() {
    supervisorScope {
        launch {
            println("Corrotina 1 executando...")
            throw RuntimeException("Erro na Corrotina 1")
        }
        launch {
            println("Corrotina 2 executando...")
        }
    }
    println("SupervisorScope concluído.")
}

5 – Comparação: coroutineScope vs. supervisorScope

Aspecto	coroutineScope	supervisorScope
Cancelamento	Cancela todas as corrotinas em caso de falha.	Apenas a corrotina com erro é cancelada.
Relacionamento entre tarefas	Corrotinas dependentes umas das outras.	Corrotinas independentes.
Quando usar	Quando todas as tarefas precisam ter sucesso.	Quando as tarefas podem falhar independentemente.

6 – Conclusão

Escopos são ferramentas poderosas no Kotlin para gerenciar o ciclo de vida de corrotinas. Eles ajudam a evitar vazamentos de recursos e facilitam o cancelamento de tarefas desnecessárias.

Resumo dos Escopos:

CoroutineScope: Para escopos personalizados.
viewModelScope: Para gerenciar corrotinas vinculadas a ViewModels no Android.
coroutineScope: Para escopos temporários onde todas as tarefas dependem umas das outras.
supervisorScope: Para tarefas independentes. No próximo artigo, exploraremos os métodos utilitários e métodos de execução que você pode usar para otimizar ainda mais suas corrotinas.

Referência
Documentação oficial do Kotlin sobre corrotinas

Dispatchers e Contextos no Kotlin: Escolhendo o Lugar Certo para Suas Corrotinas

Alan Gomes — Thu, 20 Feb 2025 08:00:00 +0000

1 – Introdução

As corrotinas no Kotlin são uma solução moderna para programação assíncrona. Mas para aproveitar todo o potencial delas, é essencial entender como funcionam os Dispatchers e Contextos.

O que são Dispatchers?

Dispatchers definem onde e como as corrotinas serão executadas. Eles permitem que você escolha o ambiente ideal para cada tarefa, seja na thread principal, em um pool de threads para I/O, ou até mesmo sem vinculação a threads específicas.

Neste artigo, você aprenderá sobre os principais tipos de Dispatchers e como usá-los para controlar o contexto das suas corrotinas.

2 – O Que São Dispatchers e Contextos?

No Kotlin, o contexto de uma corrotina é uma combinação de informações que definem:

O Dispatcher: Quem e onde executará a tarefa (ex.: Dispatchers.IO para leitura de dados).
O Job: O gerenciador da corrotina, responsável por controlar seu ciclo de vida (não abordaremos Job em detalhes aqui).

O Dispatcher é o componente mais importante para determinar como a tarefa será executada. Ele ajuda a otimizar a performance distribuindo as tarefas corretamente.

3 – Principais Dispatchers

3.1 – Dispatchers.Main

O que é? Usado para executar tarefas na thread principal, ideal para interações com a UI.
Quando usar? Para atualizações de interface em aplicativos Android ou Desktop.
Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.Main) {
        println("Executando na Thread Principal: ${Thread.currentThread().name}")
    }
}

3.2 – Dispatchers.IO

O que é?
Otimizado para tarefas de entrada e saída (Input/Output), como leitura/escrita de arquivos ou chamadas de APIs.
Quando usar?
Para operações que envolvem leitura ou gravação intensiva de dados.

Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.IO) {
        println("Executando no Dispatcher IO: ${Thread.currentThread().name}")
    }
}

3.3 – Dispatchers.Default

O que é?
Projetado para operações intensivas de CPU, como cálculos complexos ou processamento de dados em massa.
Quando usar?
Para tarefas que exigem muito poder de processamento.

Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.Default) {
        println("Executando no Dispatcher Default: ${Thread.currentThread().name}")
    }
}

4 – Conclusão

Os Dispatchers no Kotlin são ferramentas essenciais para otimizar a execução de tarefas assíncronas. Eles permitem que você escolha o ambiente certo para cada tarefa, garantindo performance e escalabilidade.

Resumo dos Dispatchers:

Dispatchers.Main: Para interações com a UI.
Dispatchers.IO: Para tarefas de entrada/saída.
Dispatchers.Default: Para cálculos intensivos.

No próximo artigo, exploraremos como os escopos ajudam a gerenciar o ciclo de vida das corrotinas de forma eficiente.

Referência
Documentação oficial do Kotlin sobre corrotinas

Dispatchers and Contexts in Kotlin: Choosing the Right Place for Your Coroutines

Alan Gomes — Thu, 20 Feb 2025 08:00:00 +0000

1 – Introduction

Coroutines in Kotlin are a modern solution for asynchronous programming. But to take full advantage of them, it is essential to understand how Dispatchers and Contexts work.

What are Dispatchers?
Dispatchers define where and how coroutines will run. They allow you to choose the ideal environment for each task, whether on the main thread, in a thread pool for I/O, or even without binding to specific threads.

In this article, you will learn about the main types of Dispatchers and how to use them to control the context of your coroutines .

2 – What are Dispatchers and Contexts?

In Kotlin, a coroutine's context is a combination of information that defines:

The Dispatcher: Who and where will execute the task (e.g. Dispatchers.IO for reading data).
The Job: The coroutine manager, responsible for controlling its life cycle (we will not cover Job in detail here).

The Dispatcher is the most important component in determining how the task will be executed. It helps optimize performance by distributing tasks correctly.

3 – Main Dispatchers

3.1 – Dispatchers.Main

What is it? Used to execute tasks on the main thread, ideal for UI interactions.
When to use? For interface updates in Android or Desktop applications.
Example:

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.Main) {
        println ("Running in Main Thread: ${ Thread.currentThread ().name}")
    }
}

3.2 – Dispatchers.IO

What is it?
Optimized for input/output tasks, such as reading/writing files or calling APIs.
When to use?
For operations involving intensive reading or writing of data.

Example:

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.IO) {
        println("Running in IO Dispatcher:${Thread.currentThread().name}")
    }
}

3.3 – Dispatchers.Default

What is it?
Designed for CPU intensive operations such as complex calculations or bulk data processing.
When to use?
For tasks that require a lot of processing power.

Example:

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.Default) {
        println ("Running in Dispatcher Default:${ Thread.currentThread().name}")
    }
}

4 – Conclusion

Dispatchers in Kotlin are essential tools for optimizing the execution of asynchronous tasks. They allow you to choose the right environment for each task, ensuring performance and scalability .

Dispatcher Summary:

Dispatchers.Main: For interactions with the UI.
Dispatchers.IO: For input/output tasks.
Dispatchers.Default: For intensive computations.

In the next article, we will explore how scopes help manage the lifecycle of coroutines efficiently.

Reference
Official Kotlin documentation on coroutines

DEV Community: Comunidade Dev Space

Optimizing Asynchronous Programming with Flows in Kotlin: Introduction to Flow

1 – Introduction

2 – What is a Flow?

3 – Creating a Flow

Simple Example of a Flow

4 – Comparison: Flow vs. Other Approaches

5 – Transforming Data with Flow

Example: Using operators like map and filter

6 – Testing Flows with Turbine

Example with Turbine

7 – Real Use Cases of Flow

7.1 – Real Time Update

7.2 – Batch Data Processing

8 – Conclusion

Otimizando Programação Assíncrona com Fluxos no Kotlin: Introdução ao `Flow`

1 – Introdução

2 – O Que é um Flow?

3 – Criando um Flow

Exemplo Simples de um Flow

4 – Comparação: Flow vs. Outras Abordagens

5 – Transformando Dados com Flow

Exemplo: Usando operadores como map e filter

6 – Testando Fluxos com Turbine

Exemplo com Turbine

7 – Casos Reais de Uso do Flow

7.1 – Atualização em Tempo Real

7.2 – Processamento de Dados em Lotes

8 – Conclusão

Asynchronous Programming in Practice with Kotlin: Real Examples and Optimization

1 – Introduction

2 – Problem Review: Blocking Tasks

Example: Brewing Synchronous Coffee

3 – Solution: Asynchronous Coffee

4 – Real Cases of Asynchronous Programming

4.1 – Loading Data into Applications

4.2 - File Processing

5 – Benefits of Thinking Asynchronously

6 – Conclusion

Programação Assíncrona na Prática com Kotlin: Exemplos Reais e Otimização

1 – Introdução

2 – Revisão do Problema: Tarefas Bloqueantes

Exemplo: Preparando Café Síncrono

3 – Solução: Café Assíncrono

4 – Casos Reais de Programação Assíncrona

4.1 – Carregamento de Dados em Aplicativos

4.2 - Processamento de Arquivos

5 – Benefícios de Pensar Assincronamente

6 – Conclusão

Unit Testing with Coroutines in Kotlin: Tools and Best Practices

1 – Introduction

2 – The Problem of Testing Asynchronous Code

3 - Kotlin Native Tools

3.1 – UnconfinedTestDispatcher

3.2 – TestCoroutineScheduler

3.3 – runTest

4 - Testing flows with the turbine library

4.1 – What is Turbine?

5 – Tool Comparison

6 – Conclusion

Testes Unitários com Corrotinas no Kotlin: Ferramentas e Boas Práticas

1 – Introdução

2 – O Problema de Testar Código Assíncrono

3 – Ferramentas Nativas do Kotlin

3.1 – UnconfinedTestDispatcher

3.2 – TestCoroutineScheduler

3.3 – runTest

4 - Testando fluxos com a biblioteca turbine

4.1 – O que é Turbine?

5 – Comparação de Ferramentas

6 – Conclusão

Utility and Execution Methods in Kotlin: Working with Coroutines

1 – Introduction

2 – Utility Methods

2.1 – withTimeout

2.2 - withTimeoutOrNull

2.3 – withContext

2.4 – delay

2.5 – yield

3 – Execution Methods

2 – What is a `Flow`?

3 – Creating a `Flow`

Simple Example of a `Flow`

5 – Transforming Data with `Flow`

Example: Using operators like `map` and `filter`

7 – Real Use Cases of `Flow`

2 – O Que é um `Flow`?

3 – Criando um `Flow`

Exemplo Simples de um `Flow`

5 – Transformando Dados com `Flow`

Exemplo: Usando operadores como `map` e `filter`

7 – Casos Reais de Uso do `Flow`