Rafael

Engenheiro de Software

Olá, Eu sou Rafael. Estou construindo coisas para a web e mobile.

Um desenvolvedor dedicado a criar experiências digitais de alto desempenho, acessíveis e limpas. Eu me especializo em transformar problemas complexos em soluções de engenharia elegantes.

Paralelismo em Kotlin

O paralelismo em Kotlin é atingido principalmente através de Corrotinas (Coroutines) em conjunto com Dispatchers apropriados, permitindo que tarefas rodem simultaneamente em múltiplos núcleos de CPU.

Enquanto a concorrência gerencia múltiplas tarefas (alternando entre elas), o paralelismo executa essas tarefas ao mesmo tempo.

Conceito Chave: Corrotinas + Dispatchers

Corrotinas (launch/async): São “threads leves”. Elas não bloqueiam a thread principal, permitindo que uma thread execute várias corrotinas.

Dispatchers: Definem em qual thread ou pool de threads a corrotina será executada.

Dispatchers.Default: Recomendado para paralelismo computacional (CPU-bound), como processamento de imagens ou algoritmos pesados.

Dispatchers.IO: Recomendado para tarefas I/O (rede, banco de dados), usando um pool de threads maior.

Exemplo de Código: Paralelismo com async e await

O método async inicia uma corrotina e retorna um Deferred (semelhante a um Future ou Promise). O método await() pausa a execução até que o resultado esteja pronto.

KOTLIN
import kotlinx.coroutines.*
import kotlin.system.measureTimeMillis

// Função que simula uma tarefa pesada de CPU
suspend fun calcularResultadoPesado(id: Int): Int {
    println("Calculando $id na ${Thread.currentThread().name}…")
    delay(1000) // Simula 1 segundo de processamento
    return id * 2
}

fun main() = runBlocking {
    val tempoTotal = measureTimeMillis {
        // coroutineScope garante que ambos os asyncs finalizem
        val resultado1 = async(Dispatchers.Default) { calcularResultadoPesado(1) }
        val resultado2 = async(Dispatchers.Default) { calcularResultadoPesado(2) }
        val resultado3 = async(Dispatchers.Default) { calcularResultadoPesado(3) }

        // As duas tarefas rodam em paralelo
        println("Resultado 1: ${resultado1.await()}")
        println("Resultado 2: ${resultado2.await()}")
        println("Resultado 3: ${resultado3.await()}")
    }

    // O tempo será  ~1018ms, não 3000ms, pois rodaram em paralelo
    println("Tempo total: $tempoTotal ms")
}

Não esquecer de adicionar a dependência:

KOTLIN
dependencies{
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2")
}

0 comentários

Deixe seu comentário