Android Academy · Lección

Corrutinas y funciones suspend

Escriba código asíncrono que se lea como código síncrono. Use funciones suspend, ámbitos de corrutinas y dispatchers (IO, Main, Default).

Corrutinas y funciones suspend es una lección gratuita de Android Academy en CoddyKit. Esta es la lección 3 de 6. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Android Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Android Academy incluye 6 lecciones en total.

El problema: bloquear el hilo de la interfaz

Android ejecuta todo el trabajo de la interfaz en el hilo principal. Si realiza una solicitud de red o lee una base de datos en el hilo principal, la interfaz se congela hasta que termina.

Si la interfaz se congela durante más de 5 segundos, Android muestra un diálogo de ANR (App Not Responding) y el usuario puede forzar el cierre de la aplicación.

¿Qué son las corrutinas?

Las corrutinas de Kotlin permiten escribir código asíncrono que parece secuencial, sin callbacks ni cadenas de RxJava.

Ligeras: se pueden ejecutar miles de corrutinas simultáneamente
Suspendibles: una corrutina puede pausarse y reanudarse sin bloquear un hilo
Estructuradas: respetan un ciclo de vida (ámbito)

Funciones suspend

Una función marcada con suspend puede pausar su ejecución sin bloquear el hilo. Solo se puede llamar desde otra función suspend o desde un ámbito de corrutina.

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")
}

Ámbitos de corrutinas

Cada corrutina se ejecuta dentro de un ámbito que define su ciclo de vida:

viewModelScope — se cancela cuando se elimina el ViewModel
lifecycleScope — se cancela cuando se destruye la Activity o el Fragment
GlobalScope — vive para siempre (evítelo)
runBlocking — solo para pruebas

launch frente a async

Hay dos formas de iniciar una corrutina:

launch { } — se ejecuta sin esperar un resultado y no devuelve ningún valor
async { }.await() — devuelve un resultado que puede 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: ¿en qué hilo?

Los Dispatchers controlan en qué hilo o hilos se ejecuta la corrutina:

Dispatchers.Main — hilo de la interfaz de usuario (para actualizar las vistas)
Dispatchers.IO — para operaciones de red y disco
Dispatchers.Default — para tareas que requieren mucho procesamiento de CPU

Use withContext(Dispatchers.IO) { } para cambiar de dispatcher dentro de una corrutina.

Ejemplo de viewModelScope

Obtenga datos en un ViewModel sin bloquear la interfaz de usuario:

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
        }
    }
}

Gestión de errores en corrutinas

Gestione las excepciones dentro de una corrutina con try/catch, igual que en el código habitual:

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

Corrutinas en paralelo

Ejecute dos tareas en paralelo y espere a que ambas terminen mediante 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)
}

Comprobación rápida

¿Qué dispatcher de corrutinas debe usar para las operaciones de red y de base de datos?

Repaso: corrutinas

Ahora puede escribir código asíncrono sin callbacks:

suspend fun — puede pausarse sin bloquear el hilo
viewModelScope.launch { } — inicia una corrutina en un ViewModel
withContext(Dispatchers.IO) — cambia a un hilo en segundo plano
async { }.await() — trabajo en paralelo con un resultado
try/catch funciona normalmente dentro de las corrutinas

Siguiente: el patrón Repository — separación clara entre las fuentes de datos.

Preguntas frecuentes

¿La lección «Corrutinas y funciones suspend» es gratis?

Sí — el texto completo de «Corrutinas y funciones suspend» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Android Academy, actualiza a CoddyKit PRO. El curso de Android Academy incluye 6 lecciones en total.

¿Qué aprenderé en «Corrutinas y funciones suspend»?

Escriba código asíncrono que se lea como código síncrono. Use funciones suspend, ámbitos de corrutinas y dispatchers (IO, Main, Default). Practicas Android Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Android Academy?

No se requiere experiencia previa. Android Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 6.

¿Cuánto tiempo toma la lección «Corrutinas y funciones suspend»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Android Academy?

Sí. Cada lección de Android Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Android Academy