Quais são as principais classes em Kotlin Coroutines…

Classes e conceitos principais em Kotlin Coroutines:

CoroutineScope: Define o ciclo de vida das coroutines lançadas dentro dele. Permite cancelar todas as coroutines filhas.
Job: Representa uma referência a uma coroutine. Permite rastrear seu estado, aguardar sua conclusão, cancelá-la.
Deferred: Um tipo especial de Job que representa um valor que estará disponível posteriormente. Usado para cálculos assíncronos que retornam um resultado. O resultado pode ser obtido com a função .await().
Dispatcher: Define a thread ou pool de threads onde a coroutine é executada. Os principais despachantes:
- Dispatchers.Default: Otimizado para tarefas intensivas de CPU. Usa um pool de threads compartilhado.
- Dispatchers.IO: Otimizado para operações de I/O (rede, disco). Usa uma quantidade adequada de threads.
- Dispatchers.Main: A thread principal de UI. Para atualizar a UI. Disponível em plataformas Android e outras com a dependência adequada.
- Dispatchers.Unconfined: Executa a coroutine na thread atual, mas a recomeça em qualquer thread que recomece a função suspending.
Suspending function: Função marcada com a palavra-chave suspend que pode ser suspensa e retomada posteriormente. Pode chamar outras funções suspending.
runBlocking: Bloqueia a thread atual até que todas as coroutines em seu escopo tenham terminado. Usado principalmente para testes e na função main.
launch: Inicia uma nova coroutine sem bloquear a thread atual e retorna um Job.
async: Inicia uma nova coroutine sem bloquear a thread atual e retorna um Deferred.

Exemplo de uso:

// Exemplo de uso de CoroutineScope, launch e Dispatchers.IO
import kotlinx.coroutines.*

fun main() = runBlocking {
    // Criação de CoroutineScope
    val scope = CoroutineScope(Dispatchers.IO)

    // Lançar uma coroutine no dispatcher IO
    val job: Job = scope.launch {
        // Realizar uma requisição de rede ou outra operação de I/O
        delay(1000) // Simulação de trabalho
        println("Coroutine terminada em ${Thread.currentThread().name}")
    }

    // Aguardar a conclusão da coroutine
    job.join()
    println("Função main terminada")
}

// Exemplo de uso de async e Deferred
import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferredSum: Deferred<Int> = async {
        delay(500)
        1 + 1
    }

    // Aguardar o resultado
    val result = deferredSum.await()
    println("Resultado é: $result")
}

Quais são as principais classes em Kotlin Coroutines?