PricingLoginStart free
Kotlin Academy · Lección

Fundamentos de Channel: send, receive y close

Cree canales, envíe y reciba valores y ciérrelos correctamente.

Lección 1 de 413 pasos

Fundamentos de Channel: send, receive y close es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 1 de 4. 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 Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué es un canal?

Un Channel es una primitiva de corrutinas para comunicarse entre corrutinas; funciona como una cola bloqueante, pero suspendiendo la ejecución. Piense en él como una tubería: un extremo envía y el otro recibe.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val channel = Channel<Int>()
    launch {
        for (i in 1..5) channel.send(i)
        channel.close()
    }
    for (x in channel) println(x) // 1 2 3 4 5
}

send y receive

send(value) se suspende hasta que el receptor está preparado. receive() se suspende hasta que hay un valor disponible.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<String>()
    launch {
        ch.send("ping")
        println("sent")
    }
    val msg = ch.receive()
    println("received: $msg")
}

Cerrar un canal

channel.close() indica que no se enviarán más valores. Los receptores obtienen los valores restantes almacenados en el búfer y, después, el bucle for termina.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>(3)
    launch {
        repeat(3) { ch.send(it) }
        ch.close()  // signal done
    }
    for (v in ch) println(v) // 0 1 2, then loop ends
    println("Channel consumed")
}

isClosedForSend / isClosedForReceive

Compruebe el estado del canal con isClosedForSend (no se permiten más envíos) y isClosedForReceive (se han consumido todos los valores).

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>()
    launch {
        ch.send(1)
        ch.close()
    }
    println(ch.receive())
    println("isClosedForReceive: ${ch.isClosedForReceive}")
}

Builder produce

produce { } es un builder de corrutinas que crea una corrutina productora y devuelve un ReceiveChannel. El canal se cierra automáticamente cuando termina el bloque.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun CoroutineScope.squares(n: Int) = produce<Int> {
    for (i in 1..n) send(i * i)
}
fun main() = runBlocking {
    val sq = squares(5)
    for (v in sq) println(v) // 1 4 9 16 25
}

Extensión consumeEach

consumeEach { } itera sobre un canal y lo cancela si el bloque produce una excepción, evitando fugas.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = produce<String> {
        send("a"); send("b"); send("c")
    }
    ch.consumeEach { println(it) }
}

tryReceive y trySend

Alternativas que no suspenden: trySend / tryReceive devuelven un ChannelResult inmediatamente, sin suspender la ejecución.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>(1)
    val sendResult = ch.trySend(42)
    println("Sent: ${sendResult.isSuccess}")
    val recvResult = ch.tryReceive()
    println("Got: ${recvResult.getOrNull()}")
}

Fan-out: varios consumidores

Varias corrutinas pueden recibir del mismo canal y distribuir el trabajo: es el patrón fan-out.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val tasks = produce { repeat(6) { send(it) } }
    repeat(3) { worker ->
        launch {
            for (task in tasks) {
                println("Worker $worker: task $task")
            }
        }
    }
}

Fan-in: varios productores

Varias corrutinas pueden enviar al mismo canal y combinar sus salidas: es el patrón fan-in.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val results = Channel<String>()
    repeat(3) { i ->
        launch { results.send("result-$i") }
    }
    launch {
        repeat(3) { println(results.receive()) }
        results.close()
    }
}

Patrón de canalización

Encadene canales en una canalización en la que cada etapa lea de un canal y escriba en otro; es ideal para los flujos de trabajo de procesamiento de datos.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun CoroutineScope.numbers() = produce { for (i in 1..5) send(i) }
fun CoroutineScope.doubled(input: ReceiveChannel<Int>) = produce { for (v in input) send(v * 2) }
fun main() = runBlocking {
    val nums = numbers()
    val doubled = doubled(nums)
    for (v in doubled) println(v) // 2 4 6 8 10
    coroutineContext.cancelChildren()
}

Canal frente a Flow

Los canales son activos y mantienen estado: existen independientemente del consumo. Los flujos son fríos y declarativos: se reinician con cada recopilación. Prefiera Flow para los flujos de datos y use Channel para la comunicación entre productores y consumidores.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
import kotlinx.coroutines.flow.*
// Flow (cold): each collect() re-runs the block
// Channel (hot): shared; multiple receivers share the same stream
fun main() = runBlocking { println("Flow = cold; Channel = hot") }

Comprobación rápida

¿Qué sucede cuando llama a channel.close()?

Responde en la lección interactiva

Resumen

send y receive se suspenden hasta que el otro extremo está preparado. close() indica que se ha completado la operación. Use produce para productores que se cierran automáticamente, consumeEach para iteraciones seguras y canales para los patrones fan-out/fan-in.

Gratis para empezar

Aprende Kotlin con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos
51
Lecciones
203
Empezar a aprender gratisVer el curso completo

Preguntas frecuentes

¿La lección «Fundamentos de Channel: send, receive y close» es gratis?

Sí — el texto completo de «Fundamentos de Channel: send, receive y close» 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 Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Fundamentos de Channel: send, receive y close»?

Cree canales, envíe y reciba valores y ciérrelos correctamente. Practicas Kotlin 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 Kotlin Academy?

No se requiere experiencia previa. Kotlin 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 1 de 4.

¿Cuánto tiempo toma la lección «Fundamentos de Channel: send, receive y close»?

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 Kotlin Academy?

Sí. Cada lección de Kotlin 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

  1. Fundamentos de Channel: send, receive y close
  2. Tipos de Channel: Rendezvous, Buffered, Conflated y Unlimited
  3. Mutex y Semaphore para el estado compartido
  4. Actores y gestión estructurada del estado
← Volver a Kotlin Academy