Android Academy · Aula

Corrotinas e funções suspend

Escreva código assíncrono que se pareça com código síncrono. Use funções suspend, escopos de corrotinas e despachantes (IO, Main, Default).

Corrotinas e funções suspend é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 3 de 6. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 6 aulas no total.

O problema: bloqueando a thread da interface

O Android executa todo o trabalho da interface na thread principal. Se você fizer uma solicitação de rede ou ler o banco de dados na thread principal, a interface congela até a operação terminar.

Se a interface ficar congelada por mais de 5 segundos, o Android exibirá uma caixa de diálogo ANR (App Not Responding), e o usuário poderá forçar o fechamento do aplicativo.

O que são corrotinas?

As Corrotinas do Kotlin são uma forma de escrever código assíncrono que parece sequencial — sem callbacks nem cadeias de RxJava.

Leves — milhares de corrotinas podem ser executadas simultaneamente
Suspendíveis — uma corrotina pode pausar e retomar sem bloquear uma thread
Estruturadas — respeitam um ciclo de vida (escopo)

Funções suspend

Uma função marcada como suspend pode pausar sua execução sem bloquear a thread. Ela só pode ser chamada por outra função suspend ou por um escopo de corrotina.

import kotlinx.coroutines.*

suspend fun fetchData(): String {
    delay(1000)  // simulates 1 second network call
    return "Data loaded!"
}

fun main() = runBlocking {
    println("Fetching...")
    val result = fetchData()  // suspends here, doesn't block
    println(result)           // Data loaded!
    println("Done")
}

Escopos de corrotinas

Toda corrotina é executada dentro de um escopo que define seu ciclo de vida:

viewModelScope — cancelado quando o ViewModel é liberado
lifecycleScope — cancelado quando a Activity/Fragment é destruída
GlobalScope — dura para sempre (evite usá-lo)
runBlocking — somente para testes

launch versus async

Há duas formas de iniciar uma corrotina:

launch { } — dispara e esquece, sem valor de retorno
async { }.await() — retorna um resultado pelo qual você pode esperar

import kotlinx.coroutines.*

fun main() = runBlocking {
    // launch: no return value
    launch {
        delay(500)
        println("launch done")
    }

    // async: returns a Deferred<T>
    val deferred = async {
        delay(300)
        42
    }
    val result = deferred.await()
    println("async result: $result")
}

Dispatchers: qual thread?

Dispatchers controlam em qual thread(s) a coroutine é executada:

Dispatchers.Main — thread da interface (para atualizar as visualizações)
Dispatchers.IO — para operações de rede e disco
Dispatchers.Default — para tarefas que exigem muito do CPU

Use withContext(Dispatchers.IO) { } para mudar o dispatcher dentro de uma coroutine.

Exemplo de viewModelScope

Busque dados em um ViewModel sem bloquear a interface:

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

class DataViewModel : ViewModel() {

    fun loadData() {
        viewModelScope.launch {
            // Switch to IO thread for network
            val data = withContext(Dispatchers.IO) {
                // simulate network request
                delay(1000)
                "Result from server"
            }
            // Back on Main thread — safe to update UI
            _uiState.value = data
        }
    }
}

Tratamento de erros em coroutines

Trate exceções dentro de uma coroutine com try/catch, assim como no código comum:

viewModelScope.launch {
    try {
        val result = withContext(Dispatchers.IO) {
            api.fetchUser()  // may throw IOException
        }
        _user.value = result
    } catch (e: Exception) {
        _error.value = "Failed: ${e.message}"
    }
}

Coroutines paralelas

Execute duas tarefas em paralelo e aguarde ambas terminarem usando async/await:

viewModelScope.launch {
    // Both run at the same time!
    val userDeferred = async(Dispatchers.IO) { api.getUser() }
    val postsDeferred = async(Dispatchers.IO) { api.getPosts() }

    val user = userDeferred.await()
    val posts = postsDeferred.await()

    _state.value = UiState(user, posts)
}

Verificação rápida

Qual dispatcher de coroutine deve ser usado para operações de rede e banco de dados?

Recapitulação: coroutines

Agora você pode escrever código assíncrono sem callbacks:

suspend fun — pode pausar sem bloquear a thread
viewModelScope.launch { } — inicia uma coroutine em um ViewModel
withContext(Dispatchers.IO) — muda para uma thread em segundo plano
async { }.await() — trabalho paralelo com um resultado
try/catch funciona normalmente dentro de coroutines

A seguir: o padrão Repository — separação clara entre fontes de dados.

Perguntas Frequentes

A aula “Corrotinas e funções suspend” é grátis?

Sim — o texto completo de “Corrotinas e funções suspend” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 6 aulas no total.

O que vou aprender em “Corrotinas e funções suspend”?

Escreva código assíncrono que se pareça com código síncrono. Use funções suspend, escopos de corrotinas e despachantes (IO, Main, Default). Você pratica Android Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Android Academy?

Nenhuma experiência prévia é necessária. Android Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 6.

Quanto tempo leva a aula “Corrotinas e funções suspend”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Android Academy?

Sim. Cada aula de Android Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Android Academy