Threads vs. Corrotinas: Qual é a Diferença e Por Que Isso Importa?

1 – Introdução

Tanto as threads quanto as corrotinas lidam com tarefas concorrentes, mas de formas bastante diferentes. Para escolher qual abordagem utilizar, é importante entender suas diferenças e o impacto que elas têm no desempenho e na legibilidade do código.

Threads são gerenciadas pelo sistema operacional, enquanto as corrotinas são gerenciadas pelo Kotlin, oferecendo maior controle e eficiência. Ao longo deste artigo, vamos explorar essas diferenças e mostrar como as corrotinas resolvem os problemas das threads tradicionais.

---

2 – Diferença Técnica

Threads (Java):

• Gerenciadas pelo sistema operacional.
• Alto custo de criação e gerenciamento.
• Funcionam no nível de hardware, operando diretamente em núcleos de processamento.
• Podem levar a problemas como deadlocks e alto consumo de memória.

Corrotinas (Kotlin):

• Gerenciadas pela biblioteca do Kotlin.
• Muito mais leves e eficientes.
• Operam em um nível de abstração, permitindo pausar e retomar tarefas sem bloquear threads reais.
• Facilitam a escrita de código conciso e legível.

---

3 – Comparação em Tabela

Aspecto	Threads	Corrotinas
Gerenciamento	Sistema Operacional	Kotlin
Custo de criação	Alto	Baixo
Controle de ciclo de vida	Difícil	Facilitado por escopos
Bloqueio	Sim, pode bloquear threads reais.	Não, usa suspensão inteligente.
Escalabilidade	Limitada pela capacidade do SO.	Altamente escalável.

---

4 – Exemplo Prático

Vamos ver na prática como threads e corrotinas se diferenciam.

Usando Threads no Java:

public class Main {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            System.out.println("Thread 1 começando...");
            try {
                Thread.sleep(2000); // Simula tarefa longa.
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 1 finalizada.");
        });

        Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 começando...");
            try {
                Thread.sleep(1000); // Simula tarefa longa.
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 finalizada.");
        });

        thread1.start();
        thread2.start();
    }
}

Saída no console:

Thread 1 começando...
Thread 2 começando...
Thread 2 finalizada.
Thread 1 finalizada.

- Problema: Gerenciar threads manualmente exige mais código e atenção com exceções. Além disso, o Thread.sleep bloqueia as threads reais.

Usando Corrotinas no Kotlin:

import kotlinx.coroutines.*

fun main() = runBlocking {
    val corrotina1 = launch {
        println("Corrotina 1 começando...")
        delay(2000) // Suspende sem bloquear.
        println("Corrotina 1 finalizada.")
    }

    val corrotina2 = launch {
        println("Corrotina 2 começando...")
        delay(1000) // Suspende sem bloquear.
        println("Corrotina 2 finalizada.")
    }

    corrotina1.join()
    corrotina2.join()
}

Saída no console:

Corrotina 1 começando...
Corrotina 2 começando...
Corrotina 2 finalizada.
Corrotina 1 finalizada.

• Benefício: O uso de delay suspende a execução sem bloquear a thread, e o gerenciamento é simplificado com launch.

5 – Conclusão
Embora as threads sejam úteis para multitarefa, elas apresentam limitações importantes, como alto custo de criação e dificuldade de gerenciamento. As corrotinas do Kotlin são uma alternativa moderna e eficiente, permitindo que você escreva código mais legível e escalável.

No próximo artigo, exploraremos como os Dispatchers e Contextos ajudam a controlar onde e como as corrotinas são executadas.

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